perm filename JQJ.TIM[TIM,LSP] blob
sn#719105 filedate 1983-06-21 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00127 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00011 00002 SCCPP Multics
C00014 00003 SCCPP Rutgers
C00020 00004 SCCPP SAIL
C00024 00005 SCCPP Franz
C00029 00006 SCCPP Texas
C00032 00007 SCCPP Multics
C00033 00008 UTLISP 5.1
C00035 00009 LM-2
C00037 00010 InterLisp on SCORE
C00040 00011 LISP TIMING STATISTICS ON SAMPLE PROBLEM
C00044 00012 ∂07-May-81 2350 ROD
C00053 00013 ∂06-Apr-81 1153 RPG Times
C00054 00014 ∂29-Sep-81 1104 CSVAX.fateman at Berkeley Re: Timing
C00056 00015 ∂05-Oct-81 1245 SL
C00059 00016 ∂28-Jan-82 1221 pratt@Shasta (SuNet) 750 <--> 780 timings
C00070 00017 ∂15-Sep-81 0015 the tty of Geoffrey S. Goodfellow Dolphin/KL-10 Benchmark (from SUMEX bboard).
C00077 00018 ∂22-Sep-81 1137 Doug Appelt <APPELT at SRI-AI> Re: Don't
C00083 00019 Run 500. times, benchmark in deriv.mcl[tim,lsp] functionn call is (timit)
C00084 00020 ∂16-Oct-81 1037 ROD via MIT-AI DERIV
C00086 00021 ∂15-Oct-81 2343 pratt@Diablo (SuNet) Dolphin timings
C00093 00022 ∂15-Oct-81 2110 pratt@Diablo (SuNet) Dolphin benchmarks
C00094 00023 ∂17-Oct-81 1731 pratt@Diablo (SuNet) Dolphin timings
C00099 00024 New SAIL
C00101 00025 ∂06-Jul-82 1703 Kim.fateman at Berkeley Re: Progress
C00103 00026 ∂06-Jul-82 1802 Kim.fateman at Berkeley deriv
C00104 00027 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00109 00028 LM-2
C00112 00029 Takeuchi function of various types
C00123 00030 ∂09-Dec-81 0453 Griss at UTAH-20 (Martin.Griss) TAK
C00125 00031 ∂14-Nov-81 0857 Daniel L. Weinreb <dlw at MIT-AI>
C00129 00032 ∂11-Dec-81 1126 Griss at UTAH-20 (Martin.Griss)
C00153 00033 MacLisp produced LAP
C00155 00034 ∂26-Feb-81 2227 CSVAX.fateman at Berkeley
C00157 00035 ∂22-Jan-82 1656 Griss at UTAH-20 (Martin.Griss) Latest V2 VAx times
C00159 00036 ∂23-Jan-82 0931 Griss at UTAH-20 (Martin.Griss) Rep to george
C00166 00037 ∂21-Feb-82 1233 George J. Carrette <GJC at MIT-MC>
C00169 00038 ∂21-Feb-82 2132 Kim.fateman at Berkeley (tak 18. 12. 6.)
C00170 00039 ∂21-Feb-82 2134 ARPAVAX.fateman at Berkeley oops
C00171 00040 ∂21-Feb-82 2134 CSVAX.fateman at Berkeley explanation for the different times....
C00172 00041 ∂21-Feb-82 2139 Kim.fateman at Berkeley more on (tak 18 12 6)
C00174 00042 ∂22-Feb-82 0205 George J. Carrette <GJC at MIT-MC> Timing results.
C00177 00043 ∂23-Feb-82 0234 Kim.fateman at Berkeley gack, another data-point on TAK
C00179 00044 ∂23-Feb-82 1455 Kim.fateman at Berkeley translink etc
C00182 00045 ∂08-Feb-82 1947 Griss at UTAH-20 (Martin.Griss) Progress
C00185 00046 ∂03-Mar-82 2021 George J. Carrette <GJC at MIT-MC> ∂03-Mar-82 1043 George J. Carrette <GJC at MIT-MC>
C00191 00047 ∂26-Apr-82 0053 Kim.jkf at Berkeley franz tak benchmarks
C00196 00048 ∂26-Apr-82 0908 Kim.jkf at Berkeley more on tak
C00200 00049 ELISP/UCILISP
C00201 00050 ∂21-May-82 2048 Martin.Griss <Griss at UTAH-20> Latest PSL Tak times
C00203 00051 LM-2 HIC
C00204 00052 LM-2 HIC
C00205 00053 InterLisp-10
C00206 00054 SAIL
C00208 00055 ∂06-Jul-82 1724 ARPAVAX.fateman at Berkeley
C00210 00056 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00215 00057 LM-2
C00216 00058 SAIL
C00218 00059 SAIL
C00220 00060 ELISP/UCILISP
C00221 00061 T/UCILISP
C00222 00062 LM-2
C00223 00063 ∂03-Oct-82 2050 James Bennett <csd.Bennett at SU-SCORE> initial timings
C00227 00064 SAIL
C00234 00065 Franz on a 780 (Old version superceded later in this file)
C00235 00066 Multics
C00237 00067 780 Franz
C00239 00068 UTEXAS20 running UCI-LISP
C00244 00069 UTLISP 5.1
C00249 00070 ELISP/UCILISP
C00251 00071 Texas UCILISP
C00255 00072 Franz on 11/780 and 11/750
C00260 00073 ∂06-May-82 0129 Mabry Tyson <Tyson at SRI-AI> FRPOLY results for UCI Lisp
C00263 00074 LM-2
C00265 00075 ELISP/UCILISP
C00266 00076 SAIL
C00267 00077 Texas UCILISP
C00268 00078 ∂08-May-82 2148 Kim.jkf at Berkeley updated mas benchmark results
C00269 00079 Utah results
C00271 00080 SAIL
C00272 00081 ∂06-May-82 0128 Mabry Tyson <Tyson at SRI-AI> MAS results for UCI Lisp
C00274 00082 Franz
C00284 00083 SAIL FFT done 10 times
C00288 00084 Barrow's FFT times
C00290 00085 InterLisp-10
C00298 00086 ∂12-May-82 0003 Mabry Tyson <Tyson at SRI-AI> UCI-Lisp timing on Barrow FFT
C00300 00087 Various machines via Barrow
C00302 00088 LM-2
C00303 00089 TAK
C00310 00090 Incorporate this onto previous page. Results here are valid, corresponding
C00313 00091 SAIL
C00315 00092 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00320 00093 LM-2
C00330 00094 AAM Puzzle
C00332 00095 SAIL 100. 10. 4.
C00334 00096 SAIL 100. 10. 4.
C00336 00097 SAIL 100. 10. 4. (model B)
C00337 00098 SAIL
C00340 00099 SAIL
C00342 00100 SAIL
C00345 00101 Comparison of LISPS
C00347 00102 The ELISP code
C00368 00103 (FILECREATED " 5-Jul-82 12:52:49" <CL.BOYER.LISPS>IREWRITE..4 14918
C00393 00104 The Maclisp Code
C00414 00105 The ELISP test
C00415 00106 Interlisp bcompl blocklib swap and noswap
C00418 00107 Interlisp bcompl no blocklib swap and noswap
C00422 00108 Maclisp
C00428 00109 Interlisp (Dolphin and Dorado)
C00459 00110 The INTERLISP VAX test
C00462 00111 SAIL
C00464 00112 SAIL (FIXSW T)
C00466 00113 SAIL
C00468 00114 InterLisp of Dolphin, Dorado
C00470 00115 SAIL
C00473 00116 (fasload nrevers)
C00476 00117 (fasload nrevers)
C00479 00118 (fasload nrevers)
C00482 00119 (fasload nrevers)
C00484 00120 (fasload nrevers)
C00488 00121 (fasload nrevers)
C00492 00122 (fasload nrevers)
C00496 00123 (fasload nrevers)
C00497 00124 SAIL (MODEL B)
C00503 00125 Why is Kreverse faster than Greverse in the 0-7(10000) case?
C00511 00126 (fasload nreverse)
C00514 00127 (fasload traverse)
C00517 ENDMK
C⊗;
SCCPP Multics
∂06-Apr-81 1931 Bernard S. Greenberg <Greenberg at MIT-Multics> Re: Timing benchmark
Date: 6 April 1981 2147-est
From: Bernard S. Greenberg <Greenberg at MIT-Multics>
Subject: Re: Timing benchmark
To: RPG at SU-AI
Cc: "@LSPTRN.DIS[P,DOC]" at SU-AI
I ran this program three times on MIT-Multics. Heres what it said.
Runtime (secs) 86.4 86.4 86.8
gctime (secs) 2.4 3.8 2.5 (41 users out of max
set at 120)
Before we accept that this implementation is really 60 times
slower than MACLISP on SAIL, I would like to point out that
the unmodified program, sent in the mail, also ran on AI-ITS
MACLISP, also compiled, for FIVE SOLID WALL-CLOCK MINUTES (as
it did on Multics) without opening its mouth, but I quit it
before it finished on AI (several times). The KA-10 is reported
to be 2 or 3 times slower (instruction rate) than Multics.
The KL-10 at sail, given all benefit of the doubt, is NOT
TWO ORDERS OF MAGNITUDE faster than the AI KA-10.
Has anyone else encountered difficulty in making this program run
in small number of seconds of CPU time? Perhaps there is some
subtle conversion problem I missed in my perusal of this program?
(I made no modifications other than converting the characters to
lower-case, and on Multics, macroing *catch/*throw to catch/throw).
Did you compile these functions? If not, please compile them and
send those results too. Thanks.
-rpg-
SCCPP Rutgers
∂06-Apr-81 2008 HEDRICK at RUTGERS Re: Timing benchmark
Date: 6 Apr 1981 2307-EST
From: HEDRICK at RUTGERS
Subject: Re: Timing benchmark
To: RPG at SU-AI
In-Reply-To: Your message of 6-Apr-81 1602-EST
I translated your benchmark to R/UCI Lisp. The only non-obvious
translation was due to the fact that in R/UCI Lisp (as in all Lisp 1.6
derivatives) there can only be 5 arguments to compiled functions.
Fortunately the arguments beyond the 4th were always NIL in your case,
so I just eliminated them. (R/UCI Lisp has a special kind of function,
as LEXPR, that allows more than 5 arguments. However its use did not
seem necessary in this case.)
Totals, including GC:
R/UCI Lisp (with free space expanded by 50K):
interpreted: 15.0
compiled: 4.6
", NOUUO: 3.2 (of which .6 is GC)
By NOUUO I mean that linkage between compiled functions is by direct
PUSHJ, not going through the intepreter. This makes tracing and
breaking impossible. (In Elisp we will use a protocol that does not
have this problem.) Note that total runtimes are slightly better than
RPG's MACLisp timings. However more of it is runtime and less is GC.
I conjecture that this will be typical of Lisp programs whose only
arithmetic involves small integers. MACLisp will produce better
code for small integers, but will have to box and unbox them when returning
from functions or putting them into data structures, causing faster
runtime but more GC time. The first call is no different than others
because in R/UCI Lisp there is no automated expansion. We had to
explicitly expand free storage by 50K before running.
Elisp (extended addressing Lisp) does not yet have a compiler.
Therefore some of the system functions (e.g. MEMBER, CADR) are running
interpreted. This slows things down noticably. To get an idea of how
Elisp is going to work out, I compared it with a copy of R/UCI Lisp in
which the same functions are being interpreted. [The temptation is
great to simply code these things in assembly language, since there are
really only a few at this point. However I will attempt to resist this
temptation and continue to compare Elisp with this semi-interpreted
R/UCI Lisp.] Elisp uses dynamic expansion and contraction of memory.
However there is no apparent difference between the first time and
other times (possibly because memory has contracted to its initial
state by the end).
Elisp:
interpreted: 28.5 (E-box time, as used by RPG, 20.1 sec.)
R/UCI Lisp (with the same functions interpreted):
interpreted: 32.6
So Elisp is (as usual) a small amount faster than R/UCI Lisp. This
suggests that a good prediction for the final version of Elisp is 14
sec. interpreted. I am not ready to make predictions for Elisp compiled
code, as we don't know how the pager refill problem is going to affect
it. My guess is that it will be slightly slower than R/UCI Lisp, with
slowdown due to pager refills (from extended addressing) somewhat offset
by the better code generated by Utah's compiler.
Note that I normally report "normal" CPU time, not E-box times as used
by RPG. The E-box times will be noticably smaller in the case of Elisp.
I regard the use of E-box time with Elisp as problematical, since it
is significantly smaller than conventional CPU time, even with 0 load
on the system. I think this shows that E-box time omits some sort of
overhead that Elisp generates, probably pager refills (though the
documentation says that refills are not counted). Until someone convinces
me otherwise, I will regard conventional CPU time as a better index of
Elisp's load on the system. I report CPU times with fairly light (1 to 2)
load averages.
-------
SCCPP SAIL
Compiled
(RUNTIME 1.969) ;ebox
(GCTIME 29.914) ;ebox
(WRUNTIME 3.44501406)
(WGCTIME 52.3383193)
(WHOLINE 55.7833333)
2592
(RUNTIME 1.903)
(GCTIME 2.616)
(WRUNTIME 3.34783137)
(WGCTIME 4.6021686)
(WHOLINE 7.95)
2592
(RUNTIME 2.008)
(GCTIME 2.61)
(WRUNTIME 3.56552616)
(WGCTIME 4.6344738)
(WHOLINE 8.2)
2592
(RUNTIME 1.959)
(GCTIME 2.065)
(WRUNTIME 3.86217695)
(WGCTIME 4.0711564)
(WHOLINE 7.93333334)
2592
(RUNTIME 1.904)
(GCTIME 1.921)
(WRUNTIME 3.5259259)
(WGCTIME 3.55740738)
(WHOLINE 7.0833333)
Interpreted
2592
(RUNTIME 17.572)
(GCTIME 31.451)
(WRUNTIME 37.176616)
(WGCTIME 66.54005)
(WHOLINE 103.716666)
2592
(RUNTIME 17.191)
(GCTIME 2.586)
(WRUNTIME 39.1158924)
(WGCTIME 5.8841078)
(WHOLINE 45.0)
2592
(RUNTIME 17.32)
(GCTIME 2.642)
(WRUNTIME 35.8194237)
(WGCTIME 5.4639098)
(WHOLINE 41.2833333)
2592
(RUNTIME 17.414)
(GCTIME 2.103)
(WRUNTIME 40.106538)
(WGCTIME 4.84346205)
(WHOLINE 44.95)
2592
(RUNTIME 17.559)
(GCTIME 1.955)
(WRUNTIME 45.3507023)
(WGCTIME 5.049298)
(WHOLINE 50.4)
Compiled
2592
(RUNTIME 1.948)
(GCTIME 29.711)
2592
(RUNTIME 1.887)
(GCTIME 2.599)
2592
(RUNTIME 1.886)
(GCTIME 2.565)
2592
(RUNTIME 1.892)
(GCTIME 1.922)
2592
(RUNTIME 1.895)
(GCTIME 1.973)
;;; Model B
(fasload sccpp)
(timit)
Timing performed on Tuesday 04/26/83 at 12:21:49.
Cpu (- GC) Time = 1.688
Elapsed Time = 136.766666
Wholine Time = 59.9
GC Time = 35.419
Load Average Before = 0.84687555
Load Average After = 2.21817338
Average Load Average = 1.53252447
NIL
(timit)
Timing performed on Tuesday 04/26/83 at 12:24:14.
Cpu (- GC) Time = 1.644
Elapsed Time = 29.8833334
Wholine Time = 7.15
GC Time = 3.078
Load Average Before = 2.28072834
Load Average After = 2.58572388
Average Load Average = 2.4332261
NIL
(timit)
Timing performed on Tuesday 04/26/83 at 12:24:51.
Cpu (- GC) Time = 1.643
Elapsed Time = 23.1166666
Wholine Time = 8.4166666
GC Time = 2.936
Load Average Before = 2.5922866
Load Average After = 2.6549803
Average Load Average = 2.62363344
NIL
SCCPP Franz
∂11-Apr-81 1001 CSVAX.jkf at Berkeley result of pairs benchmark on franz.
Date: 11 Apr 1981 09:56:26-PST
From: CSVAX.jkf at Berkeley
To: rpg@su-ai
Subject: result of pairs benchmark on franz.
pair benchmark results
submitted by j foderaro
(csvax.jkf@berkeley)
10 april 81
Here are the results or running the pairs benchmark on Franz Lisp on
a VAX 11/780 runing Berkeley 4BSD Unix. The load average was less
than one when the timing was done. Timing on Unix is done in 60ths of
a second and the time charged to a process includes some of the system
overhead for memory management. I ran the benchmarks on an unloaded
system to reduce the interference of the memory manager.
The program was run with modification only to the test function
shown below. Perhaps you should in the future use macros like (cpu-time)
and (gc-time) and each site can define these macros.
(defun test ()
((lambda (t1 x gt)
(setq x (pairs a b () 'equal () () ()))
(setq t1 (- #-Franz (runtime)
#+Franz (car (ptime))
t1))
(setq gt (- #-Franz (status gctime)
#+Franz (cadr (ptime))
gt))
(print (length x))
(print (list 'runtime
(QUOTIENT (FLOAT (- t1 gt))
#-Franz 1000000.
#+Franz 60.)))
(print (list 'gctime
(quotient (float gt)
#-Franz 1000000.
#+Franz 60.)))
#+Franz (terpri))
#-Franz (runtime) #+Franz (car (ptime))
()
#-Franz (status gctime)
#+Franz (cadr (ptime))))
---
The size of the compiled file is 2768 bytes.
Here are the results::
Script started on Fri Apr 10 22:16:58 1981
Reval: lisp
Franz Lisp, Opus 34
-> (load 'pairs)
[fasl pairs.o]
t
-> (test)
2592(runtime 7.033333333333333)(gctime 23.53333333333333)
nil
-> (test)
2592(runtime 7.383333333333333)(gctime 4.816666666666667)
nil
-> (test)
2592(runtime 7.283333333333333)(gctime 4.366666666666667)
nil
-> (test)
2592(runtime 7.333333333333333)(gctime 4.666666666666667)
nil
-> (exit)
------
I looked at which functions were being called and it seems just about all this
benchmark does is call 'member' 10,000 times. I noticed that in our system
'memq' would do as good a job as 'member' so I replaced member by memq
and ran it with these results:
Reval: lisp
Franz Lisp, Opus 34
-> (load 'memqpairs)
[fasl memqpairs.o]
t
-> (test)
2592(runtime 1.683333333333333)(gctime 23.55)
nil
-> (test)
2592(runtime 1.733333333333333)(gctime 4.833333333333333)
nil
-> (test)
2592(runtime 1.766666666666667)(gctime 4.35)
nil
-> (test)
2592(runtime 1.783333333333333)(gctime 4.7)
nil
-> (exit)
script done on Fri Apr 10 22:21:50 1981
SCCPP Texas
∂07-Apr-81 2213 Mabry Tyson <ATP.Tyson at UTEXAS-20> SCCPP on UCI-Lisp
Date: 8 Apr 1981 0001-CST
From: Mabry Tyson <ATP.Tyson at UTEXAS-20>
Subject: SCCPP on UCI-Lisp
To: rpg at SU-AI
Results of LISP timing tests for UCI-Lisp
(Times are in the form R+G where R is the runtime (not including GC time)
and G is the GC time. All times are in seconds. "Interp" means interpreted,
"Slow" means compiled but using UUO-links, "Fast" means compiled with the UUO
links replaced by direct jumps.)
Processor
Program KL-2060 KI-1060
Interp Slow Fast Interp Slow Fast
SCCPP:
Free:
30000 14.00+2.78 5.32+2.38 3.38+2.78 53.43+8.58 21.14+11.62 12.77+11.56
14.04+2.83 5.37+2.70 3.35+2.71 20.40+11.47 12.63+11.36
3.34+2.70 20.72+11.50 12.71+11.44
60000 14.60+0.58 5.40+0.50 3.35+0.53 52.80+1.42 21.18+1.45 12.81+1.39
14.20+0.64 5.44+0.52 3.36+0.53 21.27+1.38 12.34+1.43
14.09+0.63 5.37+0.52 3.35+0.52 21.19+1.40 12.93+1.40
14.22+0.61 5.35+0.52 3.40+0.53
Notes: The functions with more than 5 arguments were changed to 5 argument
functions by making the last 3 into a list. These were involved in less than
3% of the run time so the difference is insignificant. The timings on the
2060 were with a load average less that 1. The timings on the KI-10 were with
a moderate load. The differences in the various timing runs are probably due
to system overhead due to swapping. The 30K free space examples had about 5
or 6 GC's while the 60K free space examples had one GC each.
-------
SCCPP Multics
;;; compiled
(test)
2592.
(runtime 3.690232)
(gctime 2.478373)
(test)
2592.
(runtime 3.679003)
(gctime 3.930743)
(test)
2592.
(runtime 3.693353)
(gctime 2.650682)
;;;UTLISP 5.1
Following are the timings for SCCPP for UTLISP 5.1. Because of local
interactive field length (= core size) restrictions, all runs were
submitted as batch jobs. "runtime" does not include "gctime".
Interpreted:
run#: #1 #2 #3 #4 #5
runtime: 18.15 18.17 18.25 18.22 18.26
gctime: 1.34 1.37 1.34 1.35 1.34
Run at 200000 (octal) field length with: 45300. words of free space
3030. words of full space
There were three garbage collections for each run.
Compiled:
run#: #1 #2 #3 #4 #5
runtime: 3.95 4.09 4.06 4.10 4.03
gctime: .97 .82 .84 .82 .83
Run at 20000 (octal) field length with: 45524. words of free space
2957. words of full space
There were three garbage collections for each run.
-------
;;;LM-2
;; 1. SCCPP
(DEFUN TEST-SCCPP ()
(LENGTH (TIMING "SCCPP"
(PAIRS A B () 'EQUAL () () ()))))
;; Compiled: 9.3 seconds.
;; Interpreted: 116.3 seconds.
;; This test seems to suffer from an incredibly cretinously written NCONC.
;; After adding NCONC optimizer to compiler (which will exist in 211):
;; Compiled: 7.9 seconds.
∂04-Aug-82 1052 HIC at SCRC-TENEX [DLA: forwarded]
Date: Wednesday, 4 August 1982 12:26-EDT
From: HIC at SCRC-TENEX
To: rpg at sail
Subject: [DLA: forwarded]
Date: Saturday, 31 July 1982, 09:46-EDT
From: David L. Andre <DLA>
To: HIC
cc: DLA
While I was editing UCADR, I decided to microcode a two-argument NCONC.
With this microcoded NCONC, the SCCPP benchmark radically improved:
;; Old results:
;; Compiled: 9.3 seconds.
;; Interpreted: 116.3 seconds.
;; This test seems to suffer from an incredibly cretinously written NCONC.
;; After adding NCONC optimizer to compiler (which will exist in 211):
;; Compiled: 7.9 seconds.
;; With microcoded NCONC (System 211, UCADR 920)
;; Compiled: 6.0 seconds.
You may wish to forward this to the appropriate people.
;;; InterLisp on SCORE
∂30-Sep-82 1218 James Bennett <csd.Bennett at SU-SCORE> new timings
Date: 30 Sep 1982 1207-PDT
From: James Bennett <csd.Bennett at SU-SCORE>
Subject: new timings
To: rpg at SU-AI
Stanford-Phone: (415) 497-2225
Home-Phone: (415) 322-2233
Dick,
Here they are:
6←(FLENGTH (TIME (PAIRS A B NIL 'EQUAL) 1 0]
collecting lists
3234, 10402 free cells
collecting lists
2842, 10010 free cells
collecting lists
3984, 10128 free cells
collecting lists
4052, 10196 free cells
collecting lists
16161, 16161 free cells
51493 conses
4.845 seconds
22.672 seconds, real time
2592
7←USE 4 FOR 1 IN 6
collecting lists
25873, 25873 free cells
collecting lists
9746, 10258 free cells
collecting lists
15907, 15907 free cells
collecting lists
6358, 10454 free cells
collecting lists
3642, 10298 free cells
collecting lists
4118, 10262 free cells
collecting lists
5956, 10052 free cells
collecting lists
35319, 35319 free cells
collecting lists
11874, 11874 free cells
collecting lists
38897, 38897 free cells
collecting lists
12308, 12308 free cells
205972/4 = 51493 conses
18.741/4 = 4.68525 seconds
200.712 seconds, real time
2592
10←DRIBBLE]
-------
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 LISP TIMING STATISTICS ON SAMPLE PROBLEM
C00006 ENDMK
C⊗;
LISP TIMING STATISTICS ON SAMPLE PROBLEM
Fast Dorado Microcode
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed time 104.96 278.33 159.20 113.05 163.88
SWAP time 18.82 15.89 21.47 21.36 19.38
CPU Time 86.14 262.44 137.73 91.69 144.50
Page Faults 636 687 853 945 780
Swap writes 324 157 220 150 213
Normal Dorado Microcode
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed time 157.04 160.15 160.99 166.49 161.17
SWAP time 17.74 13.58 19.94 24.00 18.81
CPU time 139.29 146.57 141.05 142.49 142.36
Page Faults 631 664 820 939 763
Swap Writes 330 117 205 246 224
Ordinary Dolphin
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed Time 802.01 857.71 829.86
SWAP time 91.82 109.08 100.45
CPU time 710.19 748.63 729.41
Page Faults 1551 1841 1696
Swap Writes 502 537 519
Production Dolphin
Timings have been adjusted by a factor of .8988764 to compensate for fast clock
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed Time 686.89 703.90 688.21 697.77 694.19
SWAP time 19.72 17.05 23.10 30.18 22.51
CPU time 667.17 686.85 665.11 667.59 671.68
Page Faults 372 494 574 638 519
Swap Writes 173 12 90 108 96
INTERLISP-10 on SRI-AI 2060
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
CPU Time 65.01 66.33 61.21 61.90 63.61
GC Time 6.82 11.21 8.55 16.30 10.72
-------
COMMENT ⊗ VALID 00006 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 ∂07-May-81 2350 ROD
C00011 00003 ∂06-Apr-81 1153 RPG Times
C00012 00004 ∂29-Sep-81 1104 CSVAX.fateman at Berkeley Re: Timing
C00014 00005 ∂05-Oct-81 1245 SL
C00017 00006 ∂28-Jan-82 1221 pratt@Shasta (SuNet) 750 <--> 780 timings
C00027 ENDMK
C⊗;
∂07-May-81 2350 ROD
To: TOB, RPG, BIS
Date: 6 May 1981 2331-PDT
From: KASHTAN
Subject: VAX-11/750 <--> VAX-11/780 benchmarks
To: quam, witkin, hanson, jirak, wilcox, meyers, larson, kennard, sad,
heathman at SRI-AI, ryland at SRI-AI, burback at SRI-AI, mcghie,
sword
Here are the complete results of the 11/750 - 11/780 benchmarks. Looks
like the 11/750 gets to memory faster (and is optimized w.r.t. getting
to memory faster) than the 11/780. It loses VERY badly when it comes to
actually executing instructions, as the execution unit is very much slower
in the 750 than the 780. This is particulary born out by the execution
benchmarks for the convolution program in various languages. The languages
vary from BLISS (which keeps the whole world in registers) to LISP (which
keeps the whole world in memory). Even though the 750 gets to memory faster,
it doesn't do you much good when it takes so long to process what you got
from memory (even a simple move).
The 750 does a good job of operand processing (especially given its relative
CPU speed) but this doesn't seem to help too much in actual program execution,
as on the 750 the execution time seems to be dominated by the instruction
execution time rather than the on the operand fetch time (as is the case on
the 780).
A note on the Richard Fateman's 750 benchmarks. Seems that all they did was
run a Liszt (Franz Lisp compiler) compile on one of Bell Labs UNIX systems.
A compiled Franz Lisp program (as Liszt is) tends to be very heavy on CALLS
and on moving things around in memory (i.e. to and from the stack). No
intermediate results are kept in registers at all. What this does is skew
the results somewhat towards a faster looking 750 (since the 750 will benefit
from any benchmarks that are heavily involved in memory referencing). What
he reported was that the 750 was indeed about 60% of the 780 in this case.
PLEASE NOTE that large IU and VLSI programs, while we might consider them
memory intensive, are really virtual memory intensive (i.e. have very large
working sets). This is not the same as the above benchmark. Most IU and
VLSI programs when compiled with good compilers will tend to do a small amount
of computation (even just an add or multiply) with each datum fetched from
memory. You can expect the performance of the 750 relative to the 780 to
drop quite a bit from the above mentioned 60%. It should become very much
like the following convolution benchmarks (a very good example of a virtual
memory intensive program that does a small amount of computation with each
datum fetched). An interesting side note: CARs and CDRs in compiled lisp
tend to come out as "movl x(r),dst" (which executes at about 60% of 780
speed).
My feeling from playing with the two systems is that the 750 is best used
as an entry level system for those sites which need to acquire the smallest
possible VAX configuration (i.e. the lowest possible price). An entry level
750 goes for about $90K while an entry level 780 system with approximately
the same configuration would go for about $140K. Clearly there is a big
difference here (almost all of it in the price of the CPU). As the systems
get larger the price advantage goes away (as the price will note be dominated
by the CPU price, which is the case in the smaller systems, but by memory /
peripheral prices). Here you will save about $50K on a $250K system and get
less than 1/2 the machine.
I am somewhat confused by the divide instruction timings. There are a couple
of possibilities here - 1) a stupidity in the 780 was fixed in the 750
2) I muffed the 780 test (don't thing so, as I
triple checked it)
3) I muffed the 750 test.
I find it incredible that MULL is 4x as fast on the 780 while DIVL is a bit
slower on the 780. I did not do any floating point tests, as there is no
floating point accelerator on the 750.
David
-------------------------------------------------------------------------------
VAX-11/750 vs VAX-11/780
------------------------
Simple 2D convolution program:
11/750 11/750 (% of 11/780) 11/780
------ -------------------- ------
BLISS-32 5.45 sec 45% 2.5 sec
VMS PASCAL 12.9 sec 38% 4.9 sec
UNIX C 11.3 sec 44% 5.0 sec
UNIX F77 39.9 sec 29% 11.4 sec
Compiled
Franz Lisp 76.5 sec 53% 41.0 sec
Instruction timings:
movl r,r 1000nSec 40% 400nSec
movl x(PC),r 1760nSec 45% 800nSec
movl r,x(PC) 2300nSec 52% 1300nSec
movl (r),r 1330nSec 60% 800nSec
Addressing modes:
r 0nSec -- 0nSec
# (short) 0nSec -- 0nSec
# (long) 700nSec 57% 400nSec
(r) 330nSec 120% 400nSec
(r)+ 330nSec 120% 400nSec
-(r) 330nSec 120% 400nSec
@(r)+ 900nSec 111% 1000nSec
x(r) 500nSec 80% 400nSec
@x(r) 1150nSec 86% 1000nSec
[r] 1000nSec 60% 600nSec
Instructions:
MOVL 1000nSec 40% 400nSec
ADDL
SUBL
etc
MULL 8000nSec 25% 2000nSec
DIVL 8000nSec 112% 9000nSec
CALLx/RET 20000nSec+1800nSec/register 15000nSec+
100% 2000nSec/Reg
JSB/RSB 6000nSec 50% 3000nSec
SOBGxx 2000nSec 50% 1000nSec
ACBL 5600nSec 71% 4000nSec
MOVC3 350nSec/byte 107% 375nSec/byte
3 operand +500nSec 40% +200nSec
instructions
-------
---------------
-------
-------
∂06-Apr-81 1153 RPG Times
kl 780 750 fv1 s1 2080
peak 3 1 0.6 2.8 20 24
scalar
ave 1.9 0.8 0.5 2.0 ? 9.5
logic
float 0.5 0.6 0.2 1.0 80 7 (claimed 12?)
(dbl
floating mult)
Peak scalar is instruction drain rate (no memory fetches), ave logic is
non-arithmetic with memory fetches. Floating is floating peak (drain rate),
in MIPs. KL (model a cpu), fv1 is super-vax (not announced).
-rpg-
∂29-Sep-81 1104 CSVAX.fateman at Berkeley Re: Timing
Date: 28 Sep 1981 16:45:34-PDT
From: CSVAX.fateman at Berkeley
To: RPG@SU-AI
Subject: Re: Timing
we ran a particular demo file for VAX macsyma (available as
mit-mc:demo;begin demo) on the 11/780 (low usage) and on
the 11/750 (single user) and found that the 11/780 did the job
in 73% of the reported CPU time of the 11/750. This was not
done with equal amounts of memory or identical disks; I believe
those factors would tend to favor the 780. This is not
the DEC "SUVAX" of earlier times, which is considerably slower than
the 750. I suspect that with the floating point accelerator, the
750 would be quite nice; especially as memory up to 8 megabytes
will be available with 64kram chips.
∂05-Oct-81 1245 SL
A VAX system is requested to handle the capabilities of ACRONYM, the integrated
vision system. ACRONYM now includes 2MB of system.
We expect it to expand as we add database facilities and new code.
It currently accomodates
only small pictures, 256x256. With large pictures, the address space will be
much larger. Current usage of the group is approximately 72% of a VAX 11/780,
or 125% of a VAX 11/750. Typical experiments require 10 minutes now on a KL/10,
equivalent to 30 minutes on a VAX 11/780. Although it is planned to make ACRONYM
more efficient, it is essential that execution time be in the range of
5 minutes for adequate debugging.
Compute power is important, thus a floating point accelerator (3% of total cost)
and interleaved memory (second memory controller (7% of total cost)).
For multiple users of large LISP systems, large memory is essential
because both VMS and UNIX impose heavy penalties in paging.
Fortunately memory is inexpensive (9.5% of total cost).
Current disk usage is estimated at 300 megabytes for reasonable functioning.
That includes inadequate storage for pictures.
A second disk is essential for adequate system performance in paging to avoid
disk contention, and a second controller makes a noticeable difference in
performance. The large disk costs only 10% more than a smaller disk and provides
room for growth and for storage of data base and images.
Pictures and archival storage will
use a tape drive along with storage at SAIL over the network.
∂28-Jan-82 1221 pratt@Shasta (SuNet) 750 <--> 780 timings
Date: 28 Jan 1982 11:57:46-PST
From: pratt at Shasta
To: equip, sun
Subject: 750 <--> 780 timings
I'd forgotten all about the following item until I stumbled across it just
now. Of interest now that we're expecting 750's.
7-May-81 10:41:55-PDT,6040;000000000001
Mail-from: ARPANET site SUMEX-AIM rcvd at 7-May-81 1041-PDT
Date: 7 May 1981 1029-PDT
From: Rindfleisch@SUMEX-AIM
Subject: FYI RE VAX 750/780 BENCHMARKS (KASHTAN)
To: SUMEX STAFF:
cc: ADMIN.GORIN@SU-SCORE, CSL.FB@SU-SCORE, PRATT@SUMEX-AIM,
cc: CSL.LANTZ@SU-SCORE, CSL.BKR@SU-SCORE, MOGUL@SCORE,
cc: NOWICKI@SCORE
Mail-from: ARPANET host SRI-AI rcvd at 7-May-81 0009-PDT
Date: 7 May 1981 0001-PDT
From: Wilcox at SRI-AI (Clark Wilcox)
Subject: [KASHTAN: VAX-11/750 <--> VAX-11/780 benchmarks]
To: rindfleisch at SUMEX-AIM
cc: Wilcox at SRI-AI
Thought you might be interested.
---------------
Date: 6 May 1981 2331-PDT
From: KASHTAN
Subject: VAX-11/750 <--> VAX-11/780 benchmarks
To: quam, witkin, hanson, jirak, wilcox, meyers, larson, kennard, sad,
heathman at SRI-AI, ryland at SRI-AI, burback at SRI-AI, mcghie,
sword
Here are the complete results of the 11/750 - 11/780 benchmarks. Looks
like the 11/750 gets to memory faster (and is optimized w.r.t. getting
to memory faster) than the 11/780. It loses VERY badly when it comes to
actually executing instructions, as the execution unit is very much slower
in the 750 than the 780. This is particulary born out by the execution
benchmarks for the convolution program in various languages. The languages
vary from BLISS (which keeps the whole world in registers) to LISP (which
keeps the whole world in memory). Even though the 750 gets to memory faster,
it doesn't do you much good when it takes so long to process what you got
from memory (even a simple move).
The 750 does a good job of operand processing (especially given its relative
CPU speed) but this doesn't seem to help too much in actual program execution,
as on the 750 the execution time seems to be dominated by the instruction
execution time rather than the on the operand fetch time (as is the case on
the 780).
A note on the Richard Fateman's 750 benchmarks. Seems that all they did was
run a Liszt (Franz Lisp compiler) compile on one of Bell Labs UNIX systems.
A compiled Franz Lisp program (as Liszt is) tends to be very heavy on CALLS
and on moving things around in memory (i.e. to and from the stack). No
intermediate results are kept in registers at all. What this does is skew
the results somewhat towards a faster looking 750 (since the 750 will benefit
from any benchmarks that are heavily involved in memory referencing). What
he reported was that the 750 was indeed about 60% of the 780 in this case.
PLEASE NOTE that large IU and VLSI programs, while we might consider them
memory intensive, are really virtual memory intensive (i.e. have very large
working sets). This is not the same as the above benchmark. Most IU and
VLSI programs when compiled with good compilers will tend to do a small amount
of computation (even just an add or multiply) with each datum fetched from
memory. You can expect the performance of the 750 relative to the 780 to
drop quite a bit from the above mentioned 60%. It should become very much
like the following convolution benchmarks (a very good example of a virtual
memory intensive program that does a small amount of computation with each
datum fetched). An interesting side note: CARs and CDRs in compiled lisp
tend to come out as "movl x(r),dst" (which executes at about 60% of 780
speed).
My feeling from playing with the two systems is that the 750 is best used
as an entry level system for those sites which need to acquire the smallest
possible VAX configuration (i.e. the lowest possible price). An entry level
750 goes for about $90K while an entry level 780 system with approximately
the same configuration would go for about $140K. Clearly there is a big
difference here (almost all of it in the price of the CPU). As the systems
get larger the price advantage goes away (as the price will note be dominated
by the CPU price, which is the case in the smaller systems, but by memory /
peripheral prices). Here you will save about $50K on a $250K system and get
less than 1/2 the machine.
I am somewhat confused by the divide instruction timings. There are a couple
of possibilities here - 1) a stupidity in the 780 was fixed in the 750
2) I muffed the 780 test (don't thing so, as I
triple checked it)
3) I muffed the 750 test.
I find it incredible that MULL is 4x as fast on the 780 while DIVL is a bit
slower on the 780. I did not do any floating point tests, as there is no
floating point accelerator on the 750.
David
-------------------------------------------------------------------------------
VAX-11/750 vs VAX-11/780
------------------------
Simple 2D convolution program:
11/750 11/750 (% of 11/780) 11/780
------ -------------------- ------
BLISS-32 5.45 sec 45% 2.5 sec
VMS PASCAL 12.9 sec 38% 4.9 sec
UNIX C 11.3 sec 44% 5.0 sec
UNIX F77 39.9 sec 29% 11.4 sec
Compiled
Franz Lisp 76.5 sec 53% 41.0 sec
Instruction timings:
movl r,r 1000nSec 40% 400nSec
movl x(PC),r 1760nSec 45% 800nSec
movl r,x(PC) 2300nSec 52% 1300nSec
movl (r),r 1330nSec 60% 800nSec
Addressing modes:
r 0nSec -- 0nSec
# (short) 0nSec -- 0nSec
# (long) 700nSec 57% 400nSec
(r) 330nSec 120% 400nSec
(r)+ 330nSec 120% 400nSec
-(r) 330nSec 120% 400nSec
@(r)+ 900nSec 111% 1000nSec
x(r) 500nSec 80% 400nSec
@x(r) 1150nSec 86% 1000nSec
[r] 1000nSec 60% 600nSec
Instructions:
MOVL 1000nSec 40% 400nSec
ADDL
SUBL
etc
MULL 8000nSec 25% 2000nSec
DIVL 8000nSec 112% 9000nSec
CALLx/RET 20000nSec+1800nSec/register 15000nSec+
100% 2000nSec/Reg
JSB/RSB 6000nSec 50% 3000nSec
SOBGxx 2000nSec 50% 1000nSec
ACBL 5600nSec 71% 4000nSec
MOVC3 350nSec/byte 107% 375nSec/byte
3 operand +500nSec 40% +200nSec
instructions
-------
---------------
-------
-------
COMMENT ⊗ VALID 00003 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 ∂15-Sep-81 0015 the tty of Geoffrey S. Goodfellow Dolphin/KL-10 Benchmark (from SUMEX bboard).
C00009 00003 ∂22-Sep-81 1137 Doug Appelt <APPELT at SRI-AI> Re: Don't
C00013 ENDMK
C⊗;
∂15-Sep-81 0015 the tty of Geoffrey S. Goodfellow Dolphin/KL-10 Benchmark (from SUMEX bboard).
Date: 15 Sep 1981 0011-PDT
Sender: GEOFF at SRI-CSL
Subject: Dolphin/KL-10 Benchmark (from SUMEX bboard).
From: the tty of Geoffrey S. Goodfellow
Reply-To: Geoff at SRI-CSL
To: DHare, Moriconi, Shostak, Levitt, JGOLDBERG
Cc: rpg at SAIL
Message-ID: <[SRI-CSL]15-Sep-81 00:11:18.GEOFF>
Date: 1 Sep 1981 1124-PDT
From: RINDFLEISCH@SUMEX-AIM
Subject: DOLPHIN/KL-10 BENCHMARK
To: Bboard
24-Aug-81 12:47:52-PDT,3542;000000000001
Mail-from: ARPANET host PARC-MAXC rcvd at 24-Aug-81 1247-PDT
Date: 24 Aug 1981 12:47 PDT
Sender: BURTON at PARC-MAXC
to: feigenbaum@sumex-aim, rindfleisch@sumex-aim
subject: Dolphin Interlisp KL-ONE benchmark
from: The Interlisp-D group (Xerox Palo Alto Research Center)
reply-to: burton
We have often been asked to summarize the overall performance of Dolphin
Interlisp relative to other systems used for AI research. However, we have foun
**d
that comparisons based on isolated single measurements (of, for example, the
number of Lisp "instructions" per second or the times taken for function call or
examples such Ackerman's function, list traversal, etc. etc.) vary wildly,
depending on what aspects of the two performance profiles they tap. It is in
response to this variability that we have characterized the Dolphin's
performance, averaged across a wide variety of measurements, in terms of KA-10
equivalents, rather than in terms of individual benchmarks.
Nevertheless, continued concern as to the adequacy of Dolphin Interlisp for
serious AI research has persuaded us that some specific demonstration of its
performance would be useful. In light of the variability of small benchmarks,
we decided to measure a large, existing Interlisp AI system running on both a
Dolphin (provided by XEOS) and a DEC KL-10. In addition to measuring a
broader range of system behavior (including swapping and garbage collection),
we felt that such a benchmark would be more representative of the
computational loads encountered in AI research.
Bill Mark and Tom Lipkis of ISI were kind enough to help us by carrying out
timing comparisons of the part of their Consul system, written in KL-ONE,
which classifies concepts into a KL-ONE network. KL-ONE is a knowledge
representation formalism developed in Interlisp at BBN which is becoming
increasingly popular in the AI community. The same source code was compiled
and run unchanged in normal production versions of both systems. No special
optimizations were done, nor were any standard system facilities (such as
garbage collection) disabled in either system.
Timings were done under a variety of load conditions on the KL-10. The load
average (LA) during the test was monitored approximately once a minute. Times
given are elapsed time, as measured with a stopwatch to guard against
unreported overhead. All times are in seconds.
elapsed total cpu gabage collection cpu less GC
Dolphin 145 139 included in cpu -
KL-10 (LA .2 - .8) 84 64.5 25.5 39
KL-10 (LA .6 - 1.0) 116 75 31 45
KL-10 (LA 1.1 - 2.1) 265 84 47 47
KL-10 (LA 2.3 - 3.5) 415 90 42 48
KL-10 (LA 4.6 - 11.3) 905 86 38 48
The dramatic variation in elapsed time indicates how misleading measures of
system internal clocks can be as measures of delivered computing power. In
terms of what the user gets, these measures indicate that a Dolphin delivers, fo
**r
this benchmark, computing power roughly comparable to that delivered by a
KL-10 with a load average of ~1.5. Further, although these figures indicate tha
**t
Dolphin Interlisp already dominates Interlisp on a KL-10 under normal operating
conditions, we expect further significant performance improvement over the next
two months.
-------
∂22-Sep-81 1137 Doug Appelt <APPELT at SRI-AI> Re: Don't
Date: 22 Sep 1981 1131-PDT
From: Doug Appelt <APPELT at SRI-AI>
Subject: Re: Don't
To: RPG at SU-AI
In-Reply-To: Your message of 22-Sep-81 1005-PDT
Dick,
Thanks for the reminder. Here it is:
Gents: the following is the timings on a run by a NL phd thesis program
on a fairly large example, exercising many parts of InterLisp, especially
spaghetti. Apparently stack fragmentation is quite a problem according to
my source:
LISP TIMING STATISTICS ON SAMPLE PROBLEM
Fast Dorado Microcode
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed time 104.96 278.33 159.20 113.05 163.88
SWAP time 18.82 15.89 21.47 21.36 19.38
CPU Time 86.14 262.44 137.73 91.69 144.50
Page Faults 636 687 853 945 780
Swap writes 324 157 220 150 213
Normal Dorado Microcode
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed time 157.04 160.15 160.99 166.49 161.17
SWAP time 17.74 13.58 19.94 24.00 18.81
CPU time 139.29 146.57 141.05 142.49 142.36
Page Faults 631 664 820 939 763
Swap Writes 330 117 205 246 224
Ordinary Dolphin
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed Time 802.01 857.71 829.86
SWAP time 91.82 109.08 100.45
CPU time 710.19 748.63 729.41
Page Faults 1551 1841 1696
Swap Writes 502 537 519
Production Dolphin
Timings have been adjusted by a factor of .8988764 to compensate for fast clock
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
Elapsed Time 686.89 703.90 688.21 697.77 694.19
SWAP time 19.72 17.05 23.10 30.18 22.51
CPU time 667.17 686.85 665.11 667.59 671.68
Page Faults 372 494 574 638 519
Swap Writes 173 12 90 108 96
INTERLISP-10 on SRI-AI 2060
Trial 1 Trial 2 Trial 3 Trial 4 Avg.
-------------------------------------------------------------------------------
CPU Time 65.01 66.33 61.21 61.90 63.61
GC Time 6.82 11.21 8.55 16.30 10.72
-------
COMMENT ⊗ VALID 00011 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00003 00002 Run 500. times, benchmark in deriv.mcl[tim,lsp] functionn call is (timit)
C00004 00003 ∂16-Oct-81 1037 ROD via MIT-AI DERIV
C00006 00004 ∂15-Oct-81 2343 pratt@Diablo (SuNet) Dolphin timings
C00013 00005 ∂15-Oct-81 2110 pratt@Diablo (SuNet) Dolphin benchmarks
C00014 00006 ∂17-Oct-81 1731 pratt@Diablo (SuNet) Dolphin timings
C00019 00007 New SAIL
C00021 00008 ∂06-Jul-82 1703 Kim.fateman at Berkeley Re: Progress
C00023 00009 ∂06-Jul-82 1802 Kim.fateman at Berkeley deriv
C00024 00010 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00029 00011 LM-2
C00030 ENDMK
C⊗;
Run 500. times, benchmark in deriv.mcl[tim,lsp] functionn call is (timit)
Interpreted SAIL MacLisp
(RUNTIME 5.612)
(GCTIME 0.346)
T
(RUNTIME 5.629)
(GCTIME 0.309)
T
(RUNTIME 5.635)
(GCTIME 0.463)
T
Compiled SAIL MacLisp
(RUNTIME 0.591)
(GCTIME 0.344)
T
(RUNTIME 0.588)
(GCTIME 0.298)
T
(RUNTIME 0.587)
(GCTIME 0.449)
T
5000. times, compiled MC MacLisp
(runtime 7.938372)
(gctime 2.58056)
∂16-Oct-81 1037 ROD via MIT-AI DERIV
To: RPG at SU-AI, VRP at SU-AI
I just ran DERIV on CADR-5. It has 192K of physical memory. I ran it in
an address space I'd been using all morning. I didn't switch anything off - i.e.
left it listening to the Chaos Net, and running the little "who line" display
at the bottom of the screen. From that display it looked like it was paging madly
as it chewed up cons cells.
Interpreted on 500. callsran it two times - both came in at between 51 and 52 seconds.
Compiled on 5000. calls ran it five times: 50.95, 59.233, 60.766, 59.3, 59.637.
[the first reading seems counter intuitively loer - it had just done the compilation
and loading, and then, I guess switched regions to the default user cons region -
may be some strange behavior of the paging algorithm which happens because the
ratio of consing to computing is so atypically high here.]
Keep in mind that this is an AI lab CADR, not a symbolics A machine, and certainly
not in the class of a Symbolics 3600. I will try it on a machine with more physical
memory when one is available.
∂16-Oct-81 1052 ROD via MIT-AI P.S.
To: RPG at SU-AI, VRP at SU-AI
They were all wall clock times, not times from internal timers.
∂15-Oct-81 2343 pratt@Diablo (SuNet) Dolphin timings
Date: 15 Oct 1981 23:34:59-PDT
From: pratt at Diablo
To: equip
Subject: Dolphin timings
I have benchmarked two Lisp programs on the Stanford Dolphins. The result was
an eye-opener for me, but came as no surprise to HPP-er Gordon Novak, who
has ported a large natural language system, ISAAC, from the U. of Texas
2060 Interlisp to Dolphin Interlisp. Gordon cited a ratio of about 28
between these two machines for all phases of Interlisp use, namely
compilation, loading, and execution. I asked him for an ISAAC demo, so he
proceeded to load his already compiled system, which he told me had taken 50
minutes to compile on the Dolphin. We chatted about features of Interlisp to
while away the 10 minutes it took the Dolphin to load his demo. He then ran
ISAAC on a number of physics problems stated in English. Problem 1 took 45
seconds. Gordon said that when running interpreted on the Dolphin this
problem had taken 180 seconds, as against 6.4 seconds running interpreted on
the 2060. He did not have timings for compiled code on the 2060, though 1-2
seconds is a reasonable guess. The remaining problems all showed similar
behavior.
Gordon commented, "This sort of performance really changes your style of using
computers. You arrange to work on other things while your program is loading,
or to go out for lunch while it is compiling."
My observations were in close agreement with Gordon's, despite my programs
being much smaller and also more CONS-intensive. One program took derivatives
of algebraic expressions. Taking the derivative of 3x↑2+ax↑2+ax+5 in Franz
Lisp on Diablo took 3.4 milliseconds, 4.8 milliseconds in a toy Lisp
system on the Sun terminal, and 6.6 milliseconds in UCI-Lisp on Sumex's KI-10.
On the Dolphin it took 160 milliseconds. (All these timings were obtained by
running the problem a large number of times, bringing the measured time up to
the order of many seconds.)
Another program converted logical formulas into disjunctive normal form. One
fairly large formula took 21 milliseconds in Franz Lisp, 29 milliseconds on the
Sun, and 1 second on the Dolphin.
Yesterday a contingent from Xerox visited Stanford to discuss Dolphins in
general and Dolphin Interlisp in particular. One topic was how to port
Interlisp programs to the Dolphin. Another was a breakdown of Interlisp
performance on the Dolphin; for example CONS was described as taking around 800
milliseconds. CONS and function-call-and-return were identified as performance
bottlenecks; CAR and CDR however were described as being fast, although no
figures were given for them. Masinter is optimistic about being able to make
30% or better improvements in the performance of CONS and call-and-return;
meanwhile one should expect particularly bad performance from programs that
make excessive use of CONS and function calls.
One conclusion from all this is that the cost-effective way to get Interlisp
cycles for those users for whom address space is not a problem is to buy a
2060, which gets you the equivalent of nearly 30 Dolphins, not to mention the
advantage of having more than one Dolphin's worth of power on those occasions
when you aren't competing with 30 other Interlisp users. I readily concede
that users running up against address space limitations have a problem.
However it is far from clear that Dolphins are the solution to that problem for
any but the most patient of users. If one is to believe Dick Gabriel's
claim that a Vax 11/780 becomes unusable with two Franz Lisp users, one must
also believe that a Dolphin becomes unusable as soon as it has more than 1/25
of an Interlisp user.
The other conclusion is that no one but a dyed-in-the-wool Interlisp enthusiast
is going to make serious use of Interlisp on the Dolphins. I am a Lisp
enthusiast myself, but not to the extent that I would bother to use a Lisp as
slow as that on the Dolphins.
Symbolics 3600's sound considerably more attractive in the light of these
Dolphin measurements. I am very anxious to see these measurements taken on the
3600.
Vaughan
∂15-Oct-81 2110 pratt@Diablo (SuNet) Dolphin benchmarks
Date: 15 Oct 1981 21:01:43-PDT
From: pratt at Diablo
To: RPG@SU-AI, VRP@SU-AI
Subject: Dolphin benchmarks
Sorry, haven't put these in a file yet. DERIV took 800 seconds compiled
against 24 seconds on the Sun for 5000 iterations. I just timed DNF a few
hours ago and got 3 seconds compiled for three iterations, so 1000 iterations
should be around 1000 seconds as against 29 seconds on the Sun. Incidentally
compilation yielded a factor of three improvement for DNF.
∂17-Oct-81 1731 pratt@Diablo (SuNet) Dolphin timings
Date: 17 Oct 1981 17:32:02-PDT
From: pratt at Diablo
To: CSD.GENESERETH@SU-SCORE at SUMEX-AIM, CSD.GERRING@SU-SCORE at SUMEX-AIM,
CSD.HBROWN@SU-SCORE at SUMEX-AIM, CSD.NOVAK@SU-SCORE, CSD.NOVAK@SU-SCORE at SUMEX-AIM,
RPG@SU-AI, SCHOEN@SUMEX-AIM, equip@SU-HPP-VAX
Subject: Dolphin timings
My apologies for appearing to be bad-mouthing the Dolphin. I'll try to get my
tests and my remarks both more neutral and more accurate in future.
Gordon is quite right about not nettling Xerox. Clearly the goal should be to
constructively encourage Xerox to improve the Dolphin in those areas where
it hurts the most. Equally clearly, this need not imply a commitment
on anyone's part to buy Dolphins in significant volume if it is eventually
concluded that they are not sufficiently effective Lisp tools. Both further
Interlisp development and further benchmarking (or just plain experience with
InterlispD), including getting programs adjusted to the Dolphin environment,
are needed before decisions of this sort can be made.
My apologies for getting Gordon's compile-time and load-time ratios wrong, I
misunderstood what he had told me about this. (The perils of being a
reporter!) My "800 milliseconds" for CONS was of course a typo for 800
microseconds, .8 seconds for a CONS would be nonsense even on an 8080. (I
wonder about that 800 microseconds. My DERIV program performed 305,000
conses and took 800 seconds. If conses take 800 microseconds then that only
accounts for 250 seconds. Hence either CONS does NOT dominate the
computation time of DERIV or CONS takes more like 2.4 milliseconds on the
Stanford Dolphins.)
I agree heartily with Gordon's statement that writing time is more important
than running time. That's why I prefer to write in a standard Lisp style,
without spending time worrying about how to transform my programs to eliminate
consing. If when I use a cons-intensive style my programs slow to a crawl then
I feel justified in lodging a performance complaint.
Gordon's upbeat remarks about using the Dolphin as a Lisp machine (which seemed
much more positive than when I was talking to him on Thursday) would appear
to contradict Dick Gabriel's feeling that a Vax 11/750 would be "unusable" on
performance grounds as a personal Lisp machine. It would be nice to get some
agreement from the Lisp community as to what level of performance is tolerable
on a personal computer. (As a Lisp user myself, I lean more to Dick's position
than Gordon's - nice environment notwithstanding, I think I'd find the Dolphin
slower than I could bear.)
Vaughan
; New SAIL
(fasload deriv)
(timit)
Timing performed on Thursday 05/27/82 at 15:29:08.
Cpu Time = 2.121
Elapsed Time = 119.15
Wholine Time = 38.133333
GC Time = 18.467
Load Average Before = 2.21320271
Load Average After = 2.36379516
Average Load Average =2.28849894
NIL
Timing performed on Thursday 05/27/82 at 15:31:20.
Cpu Time = 2.124
Elapsed Time = 63.6666665
Wholine Time = 39.2166667
GC Time = 18.021
Load Average Before = 2.18321395
Load Average After = 1.90828836
Average Load Average =2.04575115
NIL
Timing performed on Thursday 05/27/82 at 15:32:43.
Cpu Time = 2.118
Elapsed Time = 118.566667
Wholine Time = 43.3
GC Time = 18.061
Load Average Before = 1.70717573
Load Average After = 1.97787261
Average Load Average =1.84252417
NIL
∂06-Jul-82 1703 Kim.fateman at Berkeley Re: Progress
Date: 6 Jul 1982 16:49:48-PDT
From: Kim.fateman at Berkeley
To: RPG@SU-AI
Subject: Re: Progress
Cc: Kim.jkf@Berkeley
I just ran DERIV; Franz Lisp opus 38.20 on a vax 11/780 running with
a load average of between .5 and .8 (light). Recorded time 27 seconds
of which 16 were in garbage collection.
The only change to the file was to declare (localf der1 deriv).
jkf: get back to your thesis.
∂06-Jul-82 1740 ARPAVAX.fateman at Berkeley
Date: 6 Jul 1982 17:35:21-PDT
From: ARPAVAX.fateman at Berkeley
To: rpg@su-ai
Cc: ARPAVAX.jkf@Berkeley
jkf reminded me to do (sstatus translink on) to get faster times,
so with that, on a 780:
deriv = 25,2, 16.9 of which is GC
dderiv = 27.4, 17.6 of which is GC
fdderiv requires subrcall which we don't have exactly. I haven't
looked to see how funcall can work instead.
∂06-Jul-82 1802 Kim.fateman at Berkeley deriv
Date: 6 Jul 1982 17:57:22-PDT
From: Kim.fateman at Berkeley
To: rpg@su-ai
Subject: deriv
Cc: Kim.jkf@Berkeley
for a (load average 4) vax 750, no floating point accelerator, Franz opus 38.20
36.06 of which 22.2 is in GC.
I think a lighter load on the 750 would help somewhat.
∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
Date: 16 Jul 1982 0003-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: DERIV, DDERIV, FDDERIV results
To: rpg at SU-AI
Results for DERIV, DDERIV, FDDERIV for UCILISP (UT's version).
All timings are on SRI-AI's 2060 with load average around 0.2.
Notes on coding of the programs:
UCILISP open codes MAPCAR if the function is specified by a
LAMBDA expression but does not if the function is a defined function.
Therefore, (MAPCAR 'FOO BAR) was translated into (MAPCAR (FUNCTION
(LAMBDA (X) (FOO X))) BAR) to keep in the spirit of the open coded
version sent out.
DDERIV and FDDERIV involve calling a function which is the value of
a local variable. In UCILISP this may be done by simply calling
(FOO ...) where FOO is the local variable rather than fooling with
FUNCALL or SUBRCALL. This format handles both cases. With (NOUUO
NIL), these function calls do not become direct jumps (because the
value may change next time).
There was a slight problem in having the compiler produce SUBR code
to be stored under a different property (DERIV). It could be done
but not conveniently. So I just compiled the code as SUBR's and
editted the LAP code to make it load onto the DERIV property.
DDERIV and FDDERIV were the version that had the (CONS 'TIMES A) in
the definition for TIMES.
The loop was a PROG which had 5 calls to DERIV and looped 1000 times.
The function that did this was compiled to minimize the overhead.
In order to compute the overhead, I had a similar loop that called
a dummy function that just returned its arguments. Its cost was
about 0.21 seconds for the (NOUUO T) case and about 0.04 seconds
for the (NOUUO NIL) case. I did NOT subtract these out in the following
results (but I feel they should be).
Each test run produced about 265000 conses and I had about 150000 free words.
I did a GC before each run to keep things as constant as possible.
Function (NOUUO T) (NOUUO NIL)
DERIV 14.879-0.875 (.213) 4.451-0.868 (.043)
DDERIV 16.250-0.856 (.198) 4.983-0.855 (.044)
FDDERIV 16.073-0.873 (.211) 4.857-0.871 (.028)
DDERIV* 18.171-1.742 (.212) 6.091-1.717 (.043)
The format of the times are
total-gc (dummy)
where total is the total CPU time (including GC), GC is the amount used for
garbage collection and dummy is the amount of time used by the dummy loop. I
believe the clock ticks about every 0.015 seconds which explains the
difference between the .028 and .044 dummy times (one less tick).
Explanation of results:
I believe the second and third to be slower because the property list of
the variable (whose value was the property name) had to be searched twice,
first for a function property and then for the value of the variable.
Then, for the DDERIV case, another property list had to be searched to
find the function definition.
The DDERIV* case is one in which a FUNCALL is used. In UCILISP this
results in an extra CONS and a call to APPLY* which then does everything
done above. As you can see, it is slower.
-------
;;;LM-2
;; 7. DERIV
(DEFUN TEST-DERIV ()
(TIMING "DERIV" (RUN)))
;; Compiled: 23.9 seconds.
COMMENT ⊗ VALID 00026 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00004 00002 Takeuchi function of various types
C00015 00003 ∂09-Dec-81 0453 Griss at UTAH-20 (Martin.Griss) TAK
C00017 00004 ∂14-Nov-81 0857 Daniel L. Weinreb <dlw at MIT-AI>
C00021 00005 ∂11-Dec-81 1126 Griss at UTAH-20 (Martin.Griss)
C00045 00006 MacLisp produced LAP
C00047 00007 ∂26-Feb-81 2227 CSVAX.fateman at Berkeley
C00049 00008 ∂22-Jan-82 1656 Griss at UTAH-20 (Martin.Griss) Latest V2 VAx times
C00051 00009 ∂23-Jan-82 0931 Griss at UTAH-20 (Martin.Griss) Rep to george
C00058 00010 ∂21-Feb-82 1233 George J. Carrette <GJC at MIT-MC>
C00061 00011 ∂21-Feb-82 2132 Kim.fateman at Berkeley (tak 18. 12. 6.)
C00062 00012 ∂21-Feb-82 2134 ARPAVAX.fateman at Berkeley oops
C00063 00013 ∂21-Feb-82 2134 CSVAX.fateman at Berkeley explanation for the different times....
C00064 00014 ∂21-Feb-82 2139 Kim.fateman at Berkeley more on (tak 18 12 6)
C00066 00015 ∂22-Feb-82 0205 George J. Carrette <GJC at MIT-MC> Timing results.
C00069 00016 ∂23-Feb-82 0234 Kim.fateman at Berkeley gack, another data-point on TAK
C00071 00017 ∂23-Feb-82 1455 Kim.fateman at Berkeley translink etc
C00074 00018 ∂08-Feb-82 1947 Griss at UTAH-20 (Martin.Griss) Progress
C00077 00019 ∂03-Mar-82 2021 George J. Carrette <GJC at MIT-MC> ∂03-Mar-82 1043 George J. Carrette <GJC at MIT-MC>
C00083 00020 ∂26-Apr-82 0053 Kim.jkf at Berkeley franz tak benchmarks
C00088 00021 ∂26-Apr-82 0908 Kim.jkf at Berkeley more on tak
C00092 00022 ELISP/UCILISP
C00093 00023 ∂21-May-82 2048 Martin.Griss <Griss at UTAH-20> Latest PSL Tak times
C00095 00024 LM-2 HIC
C00096 00025 LM-2 HIC
C00097 00026 InterLisp-10
C00098 ENDMK
C⊗;
Takeuchi function of various types
tak (18. 12. 6.)
On 11/750 in Franz generic arith (sfc)47.6 seconds compiled (JKF time 4/26)
On 11/780 in Franz generic arith (sfc)27.6 seconds compiled (JKF time 4/26)
On 11/750 in Franz ordinary arith 19.9 seconds compiled
On 11/780 in Franz with (sfc)(TAKF) 15.8 seconds compiled (GJC time)
On 11/750 in Franz fixnum arith (sfc) 14.1 seconds compiled (JKF time 4/26)
On 2060 in InterLisp (rc/swl) 13.288 seconds compiled (rpg 8/12)
On 2060 in InterLisp (rc/swl) 12.7 seconds compiled (LM 5/7)
On 11/750 in Franz generic arith (nfc)11.6 seconds compiled (JKF time 4/26)
On Dolphin in InterLisp Nov 1981 (tr) 11.195 seconds compiled
On 11/780 in Franz (sfc) 8.4 seconds compiled (KIM time)
On 11/780 in Franz fixnum arith (sfc) 8.1 seconds compiled (JKF time 4/26)
On 11/780 in Franz (sfc) 8.35 seconds compiled (GJC time)
On 11/780 in Franz generic arith (nfc) 7.7 seconds compiled (JKF time 4/26)
On 11/780 in Franz with (nfc)(TAKF) 7.5 seconds compiled (GJC time)
On 11/750 in PSL, generic arith 7.1 seconds compiled
On 11/750 in Franz (TAKF) 6.7 seconds compiled (JKF time 4/26)
On MC (KL) in MacLisp (TAKF) 5.9 seconds compiled (GJC time)
On Dolphin May 1982 generic arith 5.74 seconds compiled (LM 5/6)
On Dolphin in InterLisp Jan 1982 (tr) 5.71 seconds compiled
On Dolphin May 1982 Inum arith (tr) 5.28 seconds compiled (LM 5/6)
On Dolphin May 1982 generic arith (tr) 5.23 seconds compiled (LM 5/6)
On 2060 in T/UCILISP (sfc) 4.801 seconds compiled (Tyson 5/5)
On 2060 in InterLisp (rc/nsw) 4.57 seconds compiled (LM 5/7)
On Symbolics LM-2 4.446 seconds compiled (HIC)
On 11/780 in Franz (TAKF) 4.3 seconds compiled (JKF time 4/26)
On 11/780 in InterLisp (load = 0) 4.24 seconds compiled
On Dolphin May 1982 gen arth (d/o) 4.21 seconds compiled (LM 5/6)
On Foonly F2 in MacLisp 4.1 seconds compiled
On Dolphin May 1982 Inum arth (d/o,tr) 3.88 seconds compiled (LM 5/6)
On Dolphin May 1982 gen arth (d/o,tr) 3.84 seconds compiled (LM 5/6)
On Apollo (MC68000) PASCAL 3.8 seconds (extra waits?)
On 11/750 in Franz, Fixnum arith 3.6 seconds compiled
On MIT CADR in ZetaLisp 3.16 seconds compiled (GJC time)
On 2060 in R/UCILISP (sfc) 3.157 seconds compiled (Hedrick 5/4)
On MIT CADR in ZetaLisp 3.1 seconds compiled (ROD time)
On MIT CADR in ZetaLisp (TAKF) 3.1 seconds compiled (GJC time)
On Symbolics LM-2 2.905 seconds compiled (HIC)
On Apollo (MC68000) PSL SYSLISP 2.93 seconds compiled
On 11/780 in NIL (TAKF) 2.8 seconds compiled (GJC time)
On 11/780 in NIL 2.7 seconds compiled (GJC time)
On 11/750 in C 2.4 seconds
On 11/780 in Franz (nfc) 2.13 seconds compiled (KIM time)
On 11/780 (Diablo) in Franz (nfc) 2.1 seconds compiled (VRP time)
On 11/780 in Franz (nfc) 2.1 seconds compiled (GJC time)
On 11/780 in Franz fixnum arith (nfc) 2.1 seconds compiled (JKF time 4/26)
On 2060 in InterLisp (bc) 2.153 seconds compiled (rpg 8/12)
On 2060 in InterLisp (bc) 2.04 seconds compiled (LM 5/7)
On 68000 in C 1.9 seconds
On 11/750 in Franz fixnum arith (lfc) 1.9 seconds compiled (JKF time 4/26)
On Apollo PSL (10Mz/1Mb/Cache) 1.679 seconds compiled
On Utah-20 in PSL Generic arith 1.672 seconds compiled
On 11/750 in PSL INUM arith 1.4 seconds compiled
On 11/780 (Diablo) in C 1.35 seconds
On 11/780 in Franz (lfc) 1.13 seconds compiled (KIM time)
On UTAH-20 in Lisp 1.6 1.1 seconds compiled
On 11/780 in Franz fixnum arith (lfc) 1.1 seconds compiled (JKF time 4/26)
On UTAH-20 in PSL Inum arith 1.077 seconds compiled
On 2060 in Elisp (nfc) 1.063 seconds compiled (Hedrick 5/4)
On 2060 in R/UCILISP (nfc) .969 seconds compiled (Hedrick 5/4)
On 2060 in T/UCILISP (nfc) .930 seconds compiled (tyson 5/5)
On SAIL (KL) in MacLisp .832 seconds compiled
On SAIL in bummed MacLisp .795 seconds compiled
On MC (KL) in MacLisp (TAKF,dcl) .789 seconds compiled
On 68000 in machine language .7 seconds
On MC (KL) in MacLisp (dcl) .677 seconds compiled
On Symbolics 3600 (no-peep,no-ifp) .633 seconds compiled (PAM 1/7/83 V222)
On SAIL in bummed MacLisp (dcl) .616 seconds compiled
On Symbolics 3600 (peep,no-ifp) .590 seconds compiled (PAM 3/10/83 V222)
On SAIL (KL) in MacLisp (dcl) .564 seconds compiled
On Dorado in InterLisp Jan 1982 (tr) .53 seconds compiled
On UTAH-20 in SYSLISP arith .526 seconds compiled
On SAIL in machine language .255 seconds (wholine)
On SAIL in machine language .184 seconds (ebox-does not include mem)
On SCORE (2060) in machine language .162 seconds (ebox)
On S-1 Mark I in machine language .114 seconds (ebox & ibox)
On Cray-1, PSL .048 seconds compiled
63609 function calls
max recursion depth is 18
average recursion depth is 15.4
(defun tak (x y z)
(cond ((not (< y x))
z)
(t (tak (tak (1- x) y z)
(tak (1- y) z x)
(tak (1- z) x y))))))
notes:
(tr) means Tail Recursion Removal
(d/o) means Display turned Off on Dolphin
(sfc) means `slow function call' in Franz (debugging setting (like (NOUUO t)))
(nfc) means `normal function call' in Franz (non-debugging setting (like (NOUUO ()))
(lfc) means `local function call' in Franz (function call directly to an entry point
using knowledge of the internals of the
function by the compiler)
(bc) means Block Compiled in InterLisp
(rc) means Regular Compiled in InterLisp
(swl) means SWapping space size set low in InterLisp
(nsw) means No SWapping space in InterLisp
(dcl) means heavy MacLisp declarations
;;; Here are the definitions of TAKF as provided by GJC. #-NIL means
;;; except in NIL, #+NIL means for NIL.
(defun takf (x y z)
(takfsub #'takfsub x y z))
#-NIL
(defun takfsub (f x y z)
(if (not (< y x))
z
(funcall f f (funcall f f (1- x) y z)
(funcall f f (1- y) z x)
(funcall f f (1- z) x y))))
#+NIL
(defun takfsub ((&function f) x y z)
;; lexical scoping of function bindings allows this.
(if (not (< y x))
z
(f #'f (f #'f (1- x) y z)
(f #'f (1- y) z x)
(f #'f (1- z) x y))))
∂09-Dec-81 0453 Griss at UTAH-20 (Martin.Griss) TAK
Date: 9 Dec 1981 0552-MST
From: Griss at UTAH-20 (Martin.Griss)
Subject: TAK
To: RPG at SU-AI
cc: griss at UTAH-20
JUST TO CONFIRM, (TAK 18 12 6), right?
I find times ranging form 0.55 sec to 3.5 sec depending on what sort of arith I
use: 0.55 is SYSLISP arith (unbox on entry, do opencoded arith), to full geeneric
arith.
On old LISP 1.6 system, we get about 1 sec, no fast arith.
I may try to make some macros for fast (Inum ?) arith; pretty easy,
simply define as sequence like:
(DM + (X)
`(BOX (WPLUS2 (UNBOX ,(CADR X)) (UNBOX ,(CADDR X)))))
where I just have to decide how cavalier I want to be about BOX and UNBOX,
ie INUM only, FIXNUMS too, With/without inline tag test...
What times do you find for (TAK 18 12 6), with some of these considerations.
Ill look at some code listing, FTP later today.
-------
Yes. (TAK 18. 12. 6.). Can you get an accurate number for Lisp 1.6?
Also, I'd like to look at the output of the compiler on this.
Thanks.
∂14-Nov-81 0857 Daniel L. Weinreb <dlw at MIT-AI>
Date: 14 November 1981 11:45-EST
From: Daniel L. Weinreb <dlw at MIT-AI>
To: RPG at SU-AI
Regarding the Takeuchi benchmark results:
The figure for "On the Dolphin" does not mean much if you don't say
which version of the software you were using. Masinter has been working
on performance improvements to the subroutine calling lately, and if you
don't make it clear whether your figure predates or postdates his work,
it is impossible to interpret it.
You might be interested to note that the Interlisp-D compiler, used on
the Dolphin, does a recursion removal on this function, doing the final
(tail-recursive outer) call to "tak" with a goto.
People in general seem to think that this is a worthless benchmark
because it is so small and tests such a small and specific set of
features, although I think that it is still worth something despite that
fact.
Masinter thinks that the only benchmarks that are worth considering are
wall-clock times. He has a benchmark of the KLONE system, showing its
wall-clock times on the Dolphin, and on a 20 (or KL-10?) under various
different load levels (measured in TOPS-20 "load average" units). His
figures show that the Dolphin equals a 20 (KL-10? I can't remember)
under a load average of 1.5. (He also shows the measured runtimes for
the 20, which are quite a bit lower than the wall-clock times even for
an unloaded 20). I think Masinter has a good point here, and I think
that this benchmark, both because of the method of timing and because it
is a real,large program is a much more significant benchmark than
anything else I have seen. That is, if I were evaluating machines, it
would impress me a lot more than values of measured runtime for "tak".
BAK is going to work on bringing up a large real Interlisp program for
ISI on Lisp Machines. Maybe we can use this to create similar
benchmarks for LM-2's. I'm not sure it can, because I think maybe the
thing BAK is converting is not a standalone application but rather is a
programming system that extendes other programs. I'll try to ask him
about it.
-- Dan
∂11-Dec-81 1126 Griss at UTAH-20 (Martin.Griss)
Date: 11 Dec 1981 1223-MST
From: Griss at UTAH-20 (Martin.Griss)
To: RPG at SU-AI
cc: Griss at UTAH-20
In-Reply-To: Your message of 11-Dec-81 1212-MST
And here is 1.6 speed, using our compiler, no fast-arith
(maybe can do with Fast ARith, If I can find the apckage):
[PHOTO: Recording initiated Wed 9-Dec-81 5:25AM]
LINK FROM GRISS, TTY 15
TOPS-20 Command processor 4(714)-2
End of COMAND.CMD.8
@<pslλ$Jλ$Jλ$Jlanguages>rlisp
[Keeping]
REDUCE 2 (University of Utah, Nov-23-81) [RLISP] ...
on 1) comp,plap,pgwd;
NIL
2) copreλ$Jλ$Jλ$Jre 80;
3) in tak16.sl;
(SETQ !*COMP T)
T
(SETQ !*PLAP T)
T
(SETQ !*PGWD T)
T
(de tak (x y z)
(cond ((null (Lessp y x)) z)
(t (tak (tak (sub1 x) y z)
(tak (sub1 y) z x)
(tak (sub1 z) x y)))))
(!*ENTRY TAK EXPR 3)
(!*ALLOC 5)
(!*LBL G0013)
(!*STORE 1 0)
(!*STORE 2 -1)
(!*STORE 3 -2)
(!*LOAD 2 1)
(!*LOAD 1 -1)
(!*LINK LESSP EXPR 2)
(!*JUMPNIL G0014)
(!*LOAD 1 0)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 -2)
(!*LOAD 2 -1)
(!*LINK TAK EXPR 3)
(!*STORE 1 -3)
(!*LOAD 1 -1)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 0)
(!*LOAD 2 -2)
(!*LINK TAK EXPR 3)
(!*STORE 1 -4)
(!*LOAD 1 -2)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 -1)
(!*LOAD 2 0)
(!*LINK TAK EXPR 3)
(!*LOAD 3 1)
(!*LOAD 2 -4)
(!*LOAD 1 -3)
(!*JUMP G0013)
(!*LBL G0014)
(!*LOAD 1 -2)
(!*DEALLOC 5)
(!*EXIT)
(!*ENTRY TAK EXPR 3)
(ADD P (C 0 0 5 5)) 270600000000
(213 P 85 16) 325620000125
G0013
(MOVEM 1 0 P) 202054000000
(MOVEM 2 -1 P) 202114777777
(MOVEM 3 -2 P) 202154777776
(MOVE 2 1) 200100000001
(MOVE 1 -1 P) 200054777777
(CALL 2 (E LESSP)) 34100021172
(JUMPE 1 G0014) 322040000000
(MOVE 1 0 P) 200054000000
(CALL 1 (E SUB1)) 34040016100
(MOVE 3 -2 P) 200154777776
(MOVE 2 -1 P) 200114777777
(CALL 3 (E TAK)) 34140163345
(MOVEM 1 -3 P) 202054777775
(MOVE 1 -1 P) 200054777777
(CALL 1 (E SUB1)) 34040016100
(MOVE 3 0 P) 200154000000
(MOVE 2 -2 P) 200114777776
(CALL 3 (E TAK)) 34140163345
(MOVEM 1 -4 P) 202054777774
(MOVE 1 -2 P) 200054777776
(CALL 1 (E SUB1)) 34040016100
(MOVE 3 -1 P) 200154777777
(MOVE 2 0 P) 200114000000
(CALL 3 (E TAK)) 34140163345
(MOVE 3 1) 200140000001
(MOVE 2 -4 P) 200114777774
(MOVE 1 -3 P) 200054777775
(JRST 0 G0013) 254000433520
G0014
(MOVE 1 -2 P) 200054777776
(SUB P (C 0 0 5 5)) 274600000000
(POPJ P) 263600000000
*** TAK 145230 BASE 33 WORDS 83599 LEFT
(0 0 5 5) 5000005
TAK
(SETQ !*TIME T)
T
TIME: 1878 MS
% Turn on Time loop
% Slow Links
(TAK 1 1 1)
1
TIME: 65 MS
(TAK 18 12 6)
7
TIME: 4977 MS
% fast links
(SETQ !*NOUUO NIL)
NIL
TIME: 66 MS
(TAK 1 1 1)
1
TIME: 54 MS
(TAK 18 12 6)
7
TIME: 1102 MS
NIL
TIME: 62 MS
4) quit;
@pop
[PHOTO: Recording terminated Wed 9-Dec-81 5:26AM]
PS, Cna you send me the S-1 code or some such; maybe we can learn some
new tricks.
-------
∂11-Dec-81 1125 Griss at UTAH-20 (Martin.Griss)
Date: 11 Dec 1981 1222-MST
From: Griss at UTAH-20 (Martin.Griss)
To: RPG at SU-AI
cc: Griss at UTAH-20
In-Reply-To: Your message of 11-Dec-81 1212-MST
Here is TAK.PHT; I would appreciate comments/suggestions on code.
We have been rather pressed for time (me hunting funding etc), so
havent speent the needed hours stdying the code sequences. We want VAX
to stabilize so I can run first PSL class next month; hacking like mad
as PSL manual, uitility modules, editor, emode, windows, packages....
---------------------------------------
[PHOTO: Recording initiated Wed 9-Dec-81 5:43AM]
LINK FROM GRISS, TTY 15
TOPS-20 Command processor 4(714)-2
End of COMAND.CMD.8
@psl:rlisp
[Keeping]
REDUCE 2 (RLisp, 1 December 81) ...
1> % LOAD SOME IMPROVED ARITH
1> IN "ARITH-TEST.RED"$%λ$J
NIL
NIL
NIL
*** (TIMERLOOP): base 562401, length 32
TIMERLOOP
*** (AVG): base 562443, length 14
AVG
*** (TESTLOOP): base 562464, length 15
TESTLOOP
*** (ITESTLOOP): base 562514, length 15
ITESTLOOP
*** (WQUOTE): base 562536, length 6
WQUOTE
FASTPLUS2
FASTTIMES2
FASTDIFFERENCE
FASTADD1
FASTSUB1
FASTZEROP
FASTMINUSP
FASTGREATERP
FASTLESSP
NIL
*** (FASTTESTLOOP): base 562613, length 13
FASTTESTLOOP
NIL
NIL
*** (WTESTLOOP): base 562635, length 12
WTESTLOOP
*** (CALL1): base 562656, length 14
CALL1
*** (CALL2): base 562701, length 14
CALL2
*** (FOO1): base 562717, length 1
FOO1
*** (FOO2): base 562720, length 5
FOO2
NIL
*** (WQUOTE): base 562725, length 6
*** Function `WQUOTE' has been redefined
WQUOTE
*** (IARITHERROR): base 562737, length 4
IARITHERROR
NIL
*** (IPLUS2): base 562746, length 15
IPLUS2
*** (ITIMES2): base 562770, length 14
ITIMES2
*** (IDIFFERENCE): base 563016, length 14
IDIFFERENCE
*** (IADD1): base 563037, length 10
IADD1
*** (ISUB1): base 563051, length 10
ISUB1
*** (IZEROP): base 563066, length 12
IZEROP
*** (IMINUSP): base 563105, length 12
IMINUSP
*** (IGREATERP): base 563124, length 17
IGREATERP
*** (ILESSP): base 563145, length 17
ILESSP
NIL
2> IN "TAK.SL'λ$J";
(SETQ !*COMP T)T
% get compiled and code listing
(SETQ !*PLAP T)T
(SETQ !*PGWD T)T
% Using Generic Arith (we believe slower than should be)
(de tak (x y z)
(cond ((null (Lessp y x)) z)
(t (tak (tak (sub1 x) y z)
(tak (sub1 y) z x)
(tak (sub1 z) x y)))))(!*ENTRY TAK EXPR 3)
(!*ALLOC 5)
(!*LBL G0002)
(!*STORE 1 0)
(!*STORE 2 -1)
(!*STORE 3 -2)
(!*JUMPWLESSP G0004 2 1)
(!*LOAD 1 3)
(!*JUMP G0001)
(!*LBL G0004)
(!*LOAD 1 0)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 -2)
(!*LOAD 2 -1)
(!*LINK TAK EXPR 3)
(!*STORE 1 -3)
(!*LOAD 1 -1)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 0)
(!*LOAD 2 -2)
(!*LINK TAK EXPR 3)
(!*STORE 1 -4)
(!*LOAD 1 -2)
(!*LINK SUB1 EXPR 1)
(!*LOAD 3 -1)
(!*LOAD 2 0)
(!*LINK TAK EXPR 3)
(!*LOAD 3 1)
(!*LOAD 2 -4)
(!*LOAD 1 -3)
(!*JUMP G0002)
(!*LBL G0001)
(!*EXIT 5)
(ADJSP ST 5) 105 17 0 00 000005
(MOVEM 1 0 ST) 202 01 0 17 000000
(MOVEM 2 -1 ST) 202 02 0 17 777777
(MOVEM 3 -2 ST) 202 03 0 17 777776
(CAMGE 2 1) 315 02 0 00 000001
(JRST 0 G0004) 254 00 0 00 563200
(MOVE 1 3) 200 01 0 00 000003
(JRST 0 G0001) 254 00 0 00 563225
(MOVE 1 0 ST) 200 01 0 17 000000
(PUSHJ ST (E SUB1)) 260 17 0 00 342453
(MOVE 3 -2 ST) 200 03 0 17 777776
(MOVE 2 -1 ST) 200 02 0 17 777777
(PUSHJ ST (E TAK)) 260 17 0 00 347356
(MOVEM 1 -3 ST) 202 01 0 17 777775
(MOVE 1 -1 ST) 200 01 0 17 777777
(PUSHJ ST (E SUB1)) 260 17 0 00 342453
(MOVE 3 0 ST) 200 03 0 17 000000
(MOVE 2 -2 ST) 200 02 0 17 777776
(PUSHJ ST (E TAK)) 260 17 0 00 347356
(MOVEM 1 -4 ST) 202 01 0 17 777774
(MOVE 1 -2 ST) 200 01 0 17 777776
(PUSHJ ST (E SUB1)) 260 17 0 00 342453
(MOVE 3 -1 ST) 200 03 0 17 777777
(MOVE 2 0 ST) 200 02 0 17 000000
(PUSHJ ST (E TAK)) 260 17 0 00 347356
(MOVE 3 1) 200 03 0 00 000001
(MOVE 2 -4 ST) 200 02 0 17 777774
(MOVE 1 -3 ST) 200 01 0 17 777775
(JRST 0 G0002) 254 00 0 00 563171
(ADJSP ST -5) 105 17 0 00 777773
(POPJ ST 0) 263 17 0 00 000000
*** (TAK): base 563170, length 31
TAK
% Using a "quick and dirty" Inum Only Arith (does do calls and checks
% of range
(de Itak (x y z)
(cond ((null (ILessp y x)) z)
(t (Itak (Itak (Isub1 x) y z)
(Itak (Isub1 y) z x)
(Itak (Isub1 z) x y)))))(!*ENTRY ITAK EXPR 3)
(!*ALLOC 5)
(!*LBL G0002)
(!*STORE 1 0)
(!*STORE 2 -1)
(!*STORE 3 -2)
(!*LOAD 2 1)
(!*LOAD 1 -1)
(!*LINK ILESSP EXPR 2)
(!*JUMPNOTEQ G0004 1 (QUOTE NIL))
(!*LOAD 1 -2)
(!*JUMP G0001)
(!*LBL G0004)
(!*LOAD 1 0)
(!*LINK ISUB1 EXPR 1)
(!*LOAD 3 -2)
(!*LOAD 2 -1)
(!*LINK ITAK EXPR 3)
(!*STORE 1 -3)
(!*LOAD 1 -1)
(!*LINK ISUB1 EXPR 1)
(!*LOAD 3 0)
(!*LOAD 2 -2)
(!*LINK ITAK EXPR 3)
(!*STORE 1 -4)
(!*LOAD 1 -2)
(!*LINK ISUB1 EXPR 1)
(!*LOAD 3 -1)
(!*LOAD 2 0)
(!*LINK ITAK EXPR 3)
(!*LOAD 3 1)
(!*LOAD 2 -4)
(!*LOAD 1 -3)
(!*JUMP G0002)
(!*LBL G0001)
(!*EXIT 5)
(ADJSP ST 5) 105 17 0 00 000005
(MOVEM 1 0 ST) 202 01 0 17 000000
(MOVEM 2 -1 ST) 202 02 0 17 777777
(MOVEM 3 -2 ST) 202 03 0 17 777776
(MOVE 2 1) 200 02 0 00 000001
(MOVE 1 -1 ST) 200 01 0 17 777777
(PUSHJ ST (E ILESSP)) 260 17 0 00 347320
(CAME 1 NIL) 312 01 0 00 000000
(JRST 0 G0004) 254 00 0 00 563244
(MOVE 1 -2 ST) 200 01 0 17 777776
(JRST 0 G0001) 254 00 0 00 563271
(MOVE 1 0 ST) 200 01 0 17 000000
(PUSHJ ST (E ISUB1)) 260 17 0 00 347321
(MOVE 3 -2 ST) 200 03 0 17 777776
(MOVE 2 -1 ST) 200 02 0 17 777777
(PUSHJ ST (E ITAK)) 260 17 0 00 347357
(MOVEM 1 -3 ST) 202 01 0 17 777775
(MOVE 1 -1 ST) 200 01 0 17 777777
(PUSHJ ST (E ISUB1)) 260 17 0 00 347321
(MOVE 3 0 ST) 200 03 0 17 000000
(MOVE 2 -2 ST) 200 02 0 17 777776
(PUSHJ ST (E ITAK)) 260 17 0 00 347357
(MOVEM 1 -4 ST) 202 01 0 17 777774
(MOVE 1 -2 ST) 200 01 0 17 777776
(PUSHJ ST (E ISUB1)) 260 17 0 00 347321
(MOVE 3 -1 ST) 200 03 0 17 777777
(MOVE 2 0 ST) 200 02 0 17 000000
(PUSHJ ST (E ITAK)) 260 17 0 00 347357
(MOVE 3 1) 200 03 0 00 000001
(MOVE 2 -4 ST) 200 02 0 17 777774
(MOVE 1 -3 ST) 200 01 0 17 777775
(JRST 0 G0002) 254 00 0 00 563232
(ADJSP ST -5) 105 17 0 00 777773
(POPJ ST 0) 263 17 0 00 000000
*** (ITAK): base 563231, length 34
ITAK
% "quick and dirty(?)" use of SYSLISP arith, all in line, full
% Fixnum range.
% Could be made into (UNBOX) (Wo ...) (BOX) for "fast-arith"
(dm Wsub1 (X) (LIST 'Wdifference (CADR X) '(WCONST 1)))(!*ENTRY WSUB1 MACRO
1)
(!*ALLOC 0)
(!*LOAD 3 (QUOTE (WCONST 1)))
(!*LOAD 2 (CAR (CDR 1)))
(!*LOAD 1 (QUOTE WDIFFERENCE))
(!*LINKE 0 LIST3 EXPR 3)
(MOVE 3 115245) 200 03 0 00 341055
(MOVE 2 1 1) 200 02 0 01 000001
(MOVE 2 0 2) 200 02 0 02 000000
(MOVE 1 (LAPCONSTANT 0)) 200 01 0 00 563303
(JRST 0 (E LIST3)) 254 00 0 00 342401
:LAPCONSTANT 0: 000 00 0 04 003336
*** (WSUB1): base 563276, length 6
WSUB1
(de Wtak (x y z)
(cond ((null (WLessp y x)) z)
(t (Wtak (Wtak (Wsub1 x) y z)
(Wtak (Wsub1 y) z x)
(Wtak (Wsub1 z) x y)))))(!*ENTRY WTAK EXPR 3)
(!*ALLOC 5)
(!*LBL G0002)
(!*STORE 1 0)
(!*STORE 2 -1)
(!*STORE 3 -2)
(!*JUMPWLESSP G0004 2 1)
(!*LOAD 1 3)
(!*JUMP G0001)
(!*LBL G0004)
(!*LOAD 3 -2)
(!*LOAD 2 -1)
(!*LOAD 1 0)
(!*WPLUS2 1 (WCONST -1))
(!*LINK WTAK EXPR 3)
(!*STORE 1 -3)
(!*LOAD 3 0)
(!*LOAD 2 -2)
(!*LOAD 1 -1)
(!*WPLUS2 1 (WCONST -1))
(!*LINK WTAK EXPR 3)
(!*STORE 1 -4)
(!*LOAD 3 -1)
(!*LOAD 2 0)
(!*LOAD 1 -2)
(!*WPLUS2 1 (WCONST -1))
(!*LINK WTAK EXPR 3)
(!*LOAD 3 1)
(!*LOAD 2 -4)
(!*LOAD 1 -3)
(!*JUMP G0002)
(!*LBL G0001)
(!*EXIT 5)
(ADJSP ST 5) 105 17 0 00 000005
(MOVEM 1 0 ST) 202 01 0 17 000000
(MOVEM 2 -1 ST) 202 02 0 17 777777
(MOVEM 3 -2 ST) 202 03 0 17 777776
(CAMGE 2 1) 315 02 0 00 000001
(JRST 0 G0004) 254 00 0 00 563316
(MOVE 1 3) 200 01 0 00 000003
(JRST 0 G0001) 254 00 0 00 563343
(MOVE 3 -2 ST) 200 03 0 17 777776
(MOVE 2 -1 ST) 200 02 0 17 777777
(MOVE 1 0 ST) 200 01 0 17 000000
(SOJ 1 0) 360 01 0 00 000000
(PUSHJ ST (E WTAK)) 260 17 0 00 347361
(MOVEM 1 -3 ST) 202 01 0 17 777775
(MOVE 3 0 ST) 200 03 0 17 000000
(MOVE 2 -2 ST) 200 02 0 17 777776
(MOVE 1 -1 ST) 200 01 0 17 777777
(SOJ 1 0) 360 01 0 00 000000
(PUSHJ ST (E WTAK)) 260 17 0 00 347361
(MOVEM 1 -4 ST) 202 01 0 17 777774
(MOVE 3 -1 ST) 200 03 0 17 777777
(MOVE 2 0 ST) 200 02 0 17 000000
(MOVE 1 -2 ST) 200 01 0 17 777776
(SOJ 1 0) 360 01 0 00 000000
(PUSHJ ST (E WTAK)) 260 17 0 00 347361
(MOVE 3 1) 200 03 0 00 000001
(MOVE 2 -4 ST) 200 02 0 17 777774
(MOVE 1 -3 ST) 200 01 0 17 777775
(JRST 0 G0002) 254 00 0 00 563307
(ADJSP ST -5) 105 17 0 00 777773
(POPJ ST 0) 263 17 0 00 000000
*** (WTAK): base 563306, length 31
WTAK
(SETQ !*TIME T)T
TIME: 7053 MS
% Turn on Time loop
(TAK 1 1 1)1
TIME: 28 MS
(SYS2INT
(WTAK (INT2SYS 1) (INT2SYS 1) (INT2SYS 1)))1
TIME: 69 MS
(TAK 18 12 6)7
TIME: 1672 MS
(SYS2INT
(WTAK (INT2SYS 18) (INT2SYS 12) (INT2SYS 6)))7
TIME: 526 MS
(ITAK 18 12 6)7
TIME: 1077 MS
NIL
TIME: 36 MS
3> QUIT;
@POP
[PHOTO: Recording terminated Wed 9-Dec-81 5:45AM]
-------
;;; MacLisp produced LAP
(LAP TAK SUBR)
(ARGS TAK (() . 3))
(PUSH P 1)
(PUSH P 2)
(PUSH P 3)
(MOVE 7 0 2)
(CAMGE 7 0 1)
(JRST 0 G0002)
(MOVEI 1 0 3)
(JSP T PDLNMK)
(JRST 0 G0001)
G0002
(MOVE 7 0 1)
(SUBI 7 1)
(PUSH FXP 7)
(MOVEI 1 0 FXP)
(CALL 3 'TAK)
(MOVE 7 @ -1 P)
(SUBI 7 1)
(MOVE 3 -2 P)
(MOVE 2 0 P)
(PUSH P 1)
(PUSH FXP 7)
(MOVEI 1 0 FXP)
(CALL 3 'TAK)
(MOVE 7 @ -1 P)
(SUBI 7 1)
(MOVE 3 -2 P)
(MOVE 2 -3 P)
(PUSH P 1)
(PUSH FXP 7)
(MOVEI 1 0 FXP)
(CALL 3 'TAK)
(MOVEI 3 0 1)
(POP P 2)
(POP P 1)
(CALL 3 'TAK)
(SUB FXP (% 0 0 3 3))
G0001
(SUB P (% 0 0 3 3))
(POPJ P)
()
∂26-Feb-81 2227 CSVAX.fateman at Berkeley
Date: 26 Feb 1981 14:42:52-PST
From: CSVAX.fateman at Berkeley
To: CSVAX.jkf@Berkeley, jlk@mit-mc, lisp-forum@mit-mc, rz@mit-mc
Cc: CSVAX.fateman@Berkeley
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←
| | UCILISP | INTERLISP | MACLISP |Franz/VAX|
|-------------+---------+-----------+---------+---------|
| Interpreter | 57.0 | 26.0 | 22.8 | 65.0 |
|-------------+---------+-----------+---------+---------|
| Compiler | 2.90 | 15.0 | 0.69 | 1.1 ** |
|-------------+---------+-----------+---------+---------|
Times are for (TAK 4 2 0), where TAK is an interesting function
defined by Mr. Ikuo Takeuchi.
(DEFUN TAK (X Y Z)
(COND ((GREATERP X Y)
(TAK (TAK (SUB1 X) Y Z)
(TAK (SUB1 Y) Z X)
(TAK (SUB1 Z) X Y) ))
(T Y) ))
(**) 5.3 with (1- x) etc [no other declarations, so greaterp is closed comp.]
4.1 with local function declaration (fast subroutine call)
1.1 with > open compiled
times on a VAX 11/780 at Berkeley, Feb. 26, 1981
∂22-Jan-82 1656 Griss at UTAH-20 (Martin.Griss) Latest V2 VAx times
Date: 22 Jan 1982 1751-MST
From: Griss at UTAH-20 (Martin.Griss)
Subject: Latest V2 VAx times
To: rpg at SU-AI
cc: griss at UTAH-20
With a new scheme of VAX tags, and recent compiler/optimizer improvements,
on our 11/750 we find for (TAK 18 12 6) [unlesswe have an error??]
PSL ordinary ("generic") arith 7.1 sec
Franz ordinary arith 19.9 sec
PSL INUM arith 1.4
C 2.4
Franz Fixnum 3.6 sec
I think numbers agree with Diablo times *2/3. We expect better ratio on 11/780,
since registers are faster!
In our V2 VAX model, LISP INUMS are tagged 0 and -1, ie, are signed 32 numbers in
27 bit range, hence are actually SYSLISP numbers, ie this is "our" fixnum mode.
Our 7.1 is so much better than Franz 19.9, since we are in INUM range, no
storage alloc at all.
We are getting better.....
I will bring latest PSL manual for you.
-------
∂23-Jan-82 0931 Griss at UTAH-20 (Martin.Griss) Rep to george
Date: 23 Jan 1982 1027-MST
From: Griss at UTAH-20 (Martin.Griss)
Subject: Rep to george
To: rpg at SU-AI
cc: griss at UTAH-20
I sent following reposnse to Charrette:
[Is the table correctly repseneting what you did with TAK]
George:
We have just gotten our second version of VAX PSL running. It is not fully
checked out (just came up last night). It is complete enough to do some
preliminary timings. As you may recall, V1 VAX PSL was comparable in speed
to Franz LISP on our 11/750 under Unix. We have improved arithmetic and
some code generation for the second build.
V2 PSL has a new tagging scheme that gives 28 bit INUMS; i.e. INUMS are
now the same as SYSLISP-integers in the previous model, so that we won't
need to use SYSLISP level integers as much. The new V2 is roughly twice as
fast as V1, i.e. appears faster than Franz (tests still incomplete, please
don't quote yet).
We redid the (TAK 18 12 6) measurements requested by Dick Gabriel, and here
is a summary:
DEC-20/60:
Ordinary LISP1.6 arith 1.1sec
Ordinary PSL arith 1.67
Inum (fast) PSL arith 1.08
SYSLISP arith .526
C (New Utah PCC Implementaton) .977 [ie SYSLISP faster than C here]
VAX 11/750:
PSL V2, ordinary arith 7.1
PSL V2, Inum arith 1.4 [inum =syslisp on VAX now]
Franz, ordinary arith 19.9
Franz, Fixnum arith 3.6 [using 1+, 1-, * etc in Franz]
C on VAX 2.4
Some reference points from Gabriel:
Dolphin 11.1
MIT CADR 3.1
Franz, Fixnum,11/780 2.1 [Diablo at Stanford]
68000 (C) 1.9
C on 11/780 1.35
SAIL Maclisp .83 ( ~.66 on DEC-20/60?)
SAIL "bummed" MACLISP .80
68000 machine code .7
SAIL machine code .184
SCORE machine code .162
S-1 machine code .114
The best MACLISP and machine code times involved open-coded
FIXNUM arithmetic, hand-unfolding of LISP recursion, and
hand-register allocation. Most of this is one automatically in
the PSL compiler.
Do you have some VAX NIL times for TAK. If you make changes from the
simple
(DEFUN TAK (X Y Z)
(COND ((NULL (lessp Y X)) Z)
(T (TAK (TAK (sub1 X) Y Z)
(TAK (sub1 Y) Z X)
(TAK (sub1 Z) X Y)))))
with "lessp" and "sub1" being different closed or open arithmetics (eg
LESSP, SUB1 or < and 1-), such as special declarations, please send
compilation conditions, declarations , sample of code. I think TAK is a bit
small to be representative, but it does show function call and arithmetic
speed.
@begin(MediumFlame)
By the way, I resent a minor implication of your explanation for the use of
Scheme to Unix for NIL VM: that others may use C, but "at MIT we have do
better/more interesting stuff"; we at UTAH may be "in the boon-docks", but
we "ain't hicks".
Our VM is written in PSL itself, since we believe PSL is good enough for
ALL facets of the work, we dont have to resort to another language.
Our PSL to machine compiler has a conventional LISP->LAP step(3 passes),
[with a very powerful, extensible, table-driven LAP]. The LAP
is then either emitted to a file, assembled and deposited in line
(resident PSL compiler), or passed to a LAP to assembly code translator.
Thus on the VAX we build our VM (kernel) by writing kernel code in PSL,
and compiling to UNIX assembler, on the DEC-20 we produce MIDAS, and
for the 68000 Apollo, we produce ASM.
I realize that PSL is not as grandiose a LISP as NIL, since our goals are
to write and maintain a reasonable LISP for DEC-20, VAX, and 68000 that is
efficient, quick to change and experiment with, powerful enough to be used
for Algebra, Graphics and VLSI research, yet managed by 2-3 g
∂21-Feb-82 1233 George J. Carrette <GJC at MIT-MC>
Date: 21 February 1982 15:33-EST
From: George J. Carrette <GJC at MIT-MC>
To: RPG at SU-AI
I'll run TAK tonight on our 780. I take it you know that there is
an incredible difference between the meaning of a function call in
Franz and the meaning of a function call in NIL. In NIL the linkage
frames are set up such that when an error happens the debugger
sees every function call, every argument to every function, and
every LOCAL variable, using a variable<->program-counter-map
which is generated by the compiler. Even though this provides for
a lot of programmer productivity it doesn't cost much, I have
measured the NIL function call at 12% more costly than Franz "fast-links,"
where the debugging is worse than in compiled maclisp. (You know
how much fun it is to debug compiled maclisp!).
I will also run this:
(defun tak (x y z) (takk #'takk x y z))
(defun takk (f x y z)
(if (not (< y x)) z (funcall f (funcall f (1- x) y x)
(funcall f (1- y) z x)
(funcall f (1- z) x y))))
This is very important, because the speed of your FUNCALL is a main
determinant of the usability of your flavor-system, or generic programming
style.
Is this enough background flaming? Sigh. It would be a great service if
you could figure a way to cast these considerations into something other
than the entrenched flame-mode I've been cast into lately by
the climate-of-the-times as it were.
∂21-Feb-82 2132 Kim.fateman at Berkeley (tak 18. 12. 6.)
Date: 21 Feb 1982 18:36:21-PST
From: Kim.fateman at Berkeley
To: rpg@su-ai
Subject: (tak 18. 12. 6.)
seems to take about 13.3 seconds using Franz opus 38, with tak
compiled as a local function, and 21.3 seconds compiled in the normal
fashion. (Any function can be compiled as a local function, but it
takes more room if a local function must also be callable from interpreted
code.)
Run on a vax 11/780 with a load average of about 2.5.
Tail merging was done by the compiler to eliminate the direct recursion.
∂21-Feb-82 2134 ARPAVAX.fateman at Berkeley oops
Date: 21 Feb 1982 19:49:54-PST
From: ARPAVAX.fateman at Berkeley
To: rpg@su-ai
Subject: oops
Something funny with those last numbers. I ran it again, this
time correctly timing it, (I hope) and I got 1.13 seconds for
local function, 8.4 seconds for normal. This still seems strange,
though.
I also timed interlisp VAX, and got about 4.5 seconds, compiled.
∂21-Feb-82 2134 CSVAX.fateman at Berkeley explanation for the different times....
Date: 21 Feb 1982 20:36:38-PST
From: CSVAX.fateman at Berkeley
To: rpg@su-ai
Subject: explanation for the different times....
(< x y) is not open coded unless the compiler can be sure both
arguments are fixnums. (< in maclisp works by accident on floats,
also). (<& x y) is the right thing to do, where the "&" is from
common lisp.
∂21-Feb-82 2139 Kim.fateman at Berkeley more on (tak 18 12 6)
Date: 21 Feb 1982 21:13:08-PST
From: Kim.fateman at Berkeley
To: rpg@su-ai
Subject: more on (tak 18 12 6)
Cc: Kim.jkf@Berkeley
Franz, interpreted, runs it in 77 seconds, Interlisp VAX interpreted
in 199.5 seconds. The interlisp compiler produces some mysterious
code, but it is clear that it also removes the tail-recursive call.
(It seems that interlisp open-compiles sub1 to a "ROTL". Since
the Franz compiler does not specialize 1- to fixnums (it must run on
bignums, too), it seems interlisp has the benefit of additional
optimization.
I look forward to your list of data points on this timing.
∂22-Feb-82 0205 George J. Carrette <GJC at MIT-MC> Timing results.
Date: 22 February 1982 05:05-EST
From: George J. Carrette <GJC at MIT-MC>
Subject: Timing results.
To: RPG at SU-AI
Here is the results I got when running "GJC;TAK >" on four lisps.
All relevant files are on "MC:GJC;TAK *" If the timings you have
for Lispm and Franz are different then please tell me about it.
---------------------------------------------------------------
| Machine |
Test | |
| Lispm | NIL | Franz D | Franz No D| Maclisp |
---------------------------------------------------------------
TAK←TEST | 3.16 | 2.7 | 8.35 | 2.1 | 0.93 |
---------------------------------------------------------------
TAKF←TEST | 3.10 | 2.8 | 15.8 | 7.5 | 5.9 |
---------------------------------------------------------------
Notes: "Franz D" is Franz with debugging, or (sstatus translink ())
"Franz N" is with without ability to backtrace, or
(sstatus translink t)
Franz and NIL timings run on a VAX-780.
Maclisp timings could be further complicated by looking
at (NOUUO T) and (*RSET ()), not to mention FIXNUM declarations
and SUBRCALL. Maclisp on KL-10.
All times in seconds.
The significance of the TAKF←TEST should be obvious.
∂23-Feb-82 0234 Kim.fateman at Berkeley gack, another data-point on TAK
Date: 22 Feb 1982 19:49:49-PST
From: Kim.fateman at Berkeley
To: rpg@su-ai
Subject: gack, another data-point on TAK
John Foderaro pointed out to me that I was running the timing with
(status translink)= nil , which is the debugging setting. It doesn't
really affect the local function, but it makes a big difference for the
"normal compile" version. It reduces it from about 8 seconds to 2.13 seconds,
which perhaps also gives you an idea of function-linkage overhead if
all calls go through the transfer table.
Thus the "best" time is still about 1.13 seconds (localfunction),
then 2.13 (normal function, translink = t), then the other data
as given. (This is for Franz Lisp, on a vax 11/780.)
Well
I must commend you and GJC for providing good results. Both you,
he, and a third party provided results for Franz that are the same to the
second decimal place. I take this as honesty all around. In any event,
for the record, could you please explain exactly the implementational
difference between TRANSLINK=T, translink=(), and the localfunction compilation?
I know what they are in general terms, but a detailed explanation would
be good. Thanks.
-rpg-
∂23-Feb-82 1455 Kim.fateman at Berkeley translink etc
Date: 23 Feb 1982 14:54:51-PST
From: Kim.fateman at Berkeley
To: rpg@su-ai
Subject: translink etc
Cc: Kim.fateman@Berkeley
Local function compilation is the simplest to explain:
a function invocation can be implemented by a jsb directly to
an entry point, if enough information is known at compile time.
This totally inhibits debugging, generally hides the name of the
local function from functions not compiled "at the same time", and
is very fast. in Franz one does (declare (localf tak)) for example.
translink: The first time a function foo is called,
a reference through a table of transfer vector pairs <name, location> is made,
by jumping to "location" associated with foo. Initially this pair is
<foo, qlinker>
Qlinker is a general calling routine which refers to the atom's (foo's)
function definition cell, accessing its definition. If the definition
is binary code, say bcd←foo then the pair in the transfer table is updated,
if translink = t, to be <foo, bcd←foo>. The function is then invoked.
The next time foo is invoked, the branch to Qlinker is avoided, and it
goes much faster.
If foo is not compiled, or if translink is NIL, then the transfer table
remains unchanged, and the overhead of going through qlinker is present
each time foo is called.
Setting translink to t leaves somewhat less information on the stack, so
the backtrace function has to work harder to find out what happened. Also,
if foo's definition cell is changed, a re-linking has to be done.
There is an analogous kind of thing in interlisp, called linked
and non-linked functions.
∂08-Feb-82 1947 Griss at UTAH-20 (Martin.Griss) Progress
Date: 8 Feb 1982 2043-MST
From: Griss at UTAH-20 (Martin.Griss)
Subject: Progress
To: rpg at SU-AI
cc: griss at UTAH-20
Latest version of VAX PSL now runs all of RLISP, and should have LAP and
compiler by end of week.
I have now (hard weekend!) gotten enough of PSL/SYSLISP compiling to 68000
to have run VERY rough TAK timing on APOLLO:
Recall TAK(18,12,6) was .52 secs on DEC-20; on Apollo is about 2.9 secs.
You had 1.9secs (C) and 0.7 secs (machine code) for 68000. Do you know what
speed (8-10Mz) and what sort of memory delays. Apollo apparently has additional
WAIT states, so I guess PSL probably comparable to C on 68000. Maybe we can get
Brown C up for Apollo or some similar scheme to compare basic times.
Perhaps someone (Pratt) could run me a basic loop, such as counting to N in
D reg, for appropriate large N:
move!.I #100000,D1
L tst D1
JZ done
subq.l #1,D1
jmp L
done exit
or some such, just to normalize speed. Would like copy of EXACT code,
either in C or in ASM(prefarably?)
M
-------
∂10-Feb-82 0542 Griss at UTAH-20 (Martin.Griss)
Date: 10 Feb 1982 0637-MST
From: Griss at UTAH-20 (Martin.Griss)
To: RPG at SU-AI
cc: Griss at UTAH-20
In-Reply-To: Your message of 9-Feb-82 2219-MST
I also have 2.9 secs, on 68000 (apollo, slower than SUN?) in SYSLISP
3.4 secs in Apollo PASCAL
-------
∂10-Feb-82 0542 Griss at UTAH-20 (Martin.Griss)
Date: 10 Feb 1982 0640-MST
From: Griss at UTAH-20 (Martin.Griss)
To: RPG at SU-AI
cc: Griss at UTAH-20
In-Reply-To: Your message of 9-Feb-82 2219-MST
PS, actually, Apollo, 68000 times: 2.93 for PSL/SYSLISP mode
3.80 for PASCAL times.
We need to check basic Apollo vs SUN speeds, I think we extra WAIT states.
-------
∂03-Mar-82 2021 George J. Carrette <GJC at MIT-MC> ∂03-Mar-82 1043 George J. Carrette <GJC at MIT-MC>
Date: 3 March 1982 23:21-EST
From: George J. Carrette <GJC at MIT-MC>
Subject: ∂03-Mar-82 1043 George J. Carrette <GJC at MIT-MC>
To: RPG at SU-AI
Heck, but that so-called BUMBED maclisp was slower than using
a simple fixnum declaration, what gives? Who did that?
(declare (fixnum (tak fixnum fixnum fixnum)
(takf fixnum fixnum fixnum)
(takfsub () fixnum fixnum fixnum)))
(defun tak←test ()
(let ((tt (runtime)))
(declare (fixnum tt))
(tak 18. 12. 6.)
(quotient (- (runtime) tt) 1.0e6)))
(defun tak (x y z)
(if (not (< y x))
z
(tak (tak (1- x) y z)
(tak (1- y) z x)
(tak (1- z) x y))))
(defun takf←test ()
(let ((tt (runtime)))
(declare (fixnum tt))
(takf 18. 12. 6.)
(quotient (- (runtime) tt) 1.0e6)))
(defun takf (x y z)
(takfsub (get 'takfsub 'subr) x y z))
(defun takfsub (f x y z)
(if (not (< y x))
z
(subrcall fixnum f f (subrcall fixnum f f (1- x) y z)
(subrcall fixnum f f (1- y) z x)
(subrcall fixnum f f (1- z) x y))))
Let me put this another way. None of the MacLisp timings on SAIL used
any declarations aside from the implicit ones in the < and 1- operators.
The ``Bummed'' MacLisp means exactly this: It is the MacLisp code that
most directly corresponds to the ``bummed'' assembly language on the
10. Here is that code. The idea is that the bottom-most leaves of the
evaluation tree are trimmed. The BTAK is tail recursive too, which makes it
faster (in the presence of equally missing declarations) than the
normal version.
tak1 caig a,(b) ;x < y quit
popj p,
tak2 add fxp,[5,,5] ;allocate 5 slots. 3 for args, 2 for temporaries
dmovem a,-2(fxp) ;move a,b,c onto the stack. add is used to push
movem c.(fxp) ;empty space, and the assumption of a large enough
;stack is used here. PUSH, ADJSP both do bounds
;checking. DMOVEM saves an instruction fetch and a
;decode.
movei a,-1(a) ;a←a-1 using the address hardware. Assumption
;is that 18 bit, non-negative arithmetic is going on
caile a,(b) ;early quit? c already contains the right result.
;this early quit just unwinds the first arm of
;the conditional. Tak2 is the entry after that arm
pushj p,tak2 ;no go on
movem c,-4(fxp) ;save result on fxp
dmove a,-1(fxp) ;get y,z
move c,-2(fxp) ;and x
movei a,-1(a) ;sub1
caile a,(b) ;early quit
pushj p,tak2
movem c,-3(fxp) ;stash result
move a,(fxp) ;z
dmove b,-2(fxp) ;x,y
movei a,-1(a) ;sub1
caile a,(b)
pushj p,tak2
dmove a,-4(fxp) ;get first 2 results, the last already in c
;notice how the choice of c as the results
;register allowed us to hack the dmove's here
sub fxp,[5,,5] ;flush temporary space
caig a,(b) ;early quit on tail recursion?
popj p, ;qed
jrst tak2 ;tail recursion
It is interesting, though, that the `bummed' version improves less with
declarations than the unbummed one. The point of this study is to try to
understand what every little change to the code does in terms of
performance relative to each other, not to `do the best' in all cases.
In any event, your comments are well taken and are being incorporated
into the record of this research. If you have any other benchmarks, let
me know. Thanks.
-rpg-
∂26-Apr-82 0053 Kim.jkf at Berkeley franz tak benchmarks
Date: 26 Apr 1982 00:40:32-PDT
From: Kim.jkf at Berkeley
To: rpg@su-ai
Subject: franz tak benchmarks
Cc: Kim.fateman@Berkeley, Kim.jkf@Berkeley
There seems to be a misunderstanding about the possible function linkages
in Franz Lisp. Your report lists, 'normal function call',
and 'fast function call'. Franz lisp users would call these 'slow
function call' and 'normal function call'. There are modes which
are even slower than 'slow function call'. You can (*rset t) and
get 'real slow function call' or bind evalhook and get
'real real slow function call'. From experience I can say that the
normal mode for franz users with compiled code is to set the
linkages on (what your report called 'fast function call'). Since
I believe the purpose of the lisp timing project was to compare lisps
as they are typically run, I hope that you use our 'linkages on' numbers
for comparison with other systems.
Your note about 'local function call' is also wrong. A function
declared local is not examined by the compiler in any greater detail
than any other function. The only requirement is that a function declared
local actually appear in the same file and that it not be a lexpr.
I re-ran all timings you requested tonight. The lisp system and
compiler which produced these timings is available to anyone who
asks for it. The source is sitting on our c70 arpanet host.
I want to thank you for taking time to organize the collection of
timing information. I find the results very interesting.
Tak benchmarks run 26 april 82 by jkf
Lisp Opus 38.13, Liszt 8.05
(cpu time in secs, no gc's occurred)
Link type 780 750
--------- ------ ------
generic slow 28.6 51.0
arithmetic normal 7.8 11.6
fixnum slow 8.3 14.8
arithmetic normal 2.1 3.3
local function n/a 1.1 1.9
calls
------
takf n/a 4.3 6.7
(with funcalls)
Key: slow = (sstatus translink nil), fasl = (sstatus translink on)
n/a = doesn't make any difference how the links are set.
The generic example uses add1, sub1, lessp. All others use the
fixnum specific operations.
takf uses funcall rather than the normal way of function calling.
Franz
Your note was well taken. I have updated my notes accordingly. Could you
please explain in more detail what the local function call accomplishes?
Perhaps a quick description of the runtime stack and some code comparing the
results of normal function call and local function call would help me
understand (and explain it to others) what's up. Thanks.
Also I will include your new benchmark in the crop.
-rpg-
∂26-Apr-82 0908 Kim.jkf at Berkeley more on tak
Date: 26 Apr 1982 08:56:02-PDT
From: Kim.jkf at Berkeley
To: rpg@su-ai
Subject: more on tak
Cc: Kim.fateman@Berkeley
I forgot to mention that our compiler does tail recursion removal.
This applies to all tak's except takf.
I don't know if it is too late to submit a function for benchmarking,
but I'll try anyway. The tak function does test function calling speed,
an important part of any lisp system. It also tests the compilation
of 1-, which is far less important. I've rewritten tak to test another
important part of a lisp system: the speed at which it cdr's down
a list. Here is takl:
;;--- takl : tak using lists as counters
;
(defun takl (x y z)
(cond ((listgeqp y x) z)
(t (takl (takl (cdr x) y z)
(takl (cdr y) z x)
(takl (cdr z) x y)))))
;--- listgeqp : t iff list a is longer or the same size as b
;
(defun listgeqp (a b)
(cond ((null b) t)
((null a) nil)
(t (listgeqp (cdr a) (cdr b)))))
I re-ran all benchmarks this morning on less loaded machines and
here are the results:
Tak benchmarks run 27 april 82 by jkf
Lisp Opus 38.13, Liszt 8.05
(cpu time in secs, no gc's occurred)
Link type 780 750
--------- ------ ------
generic slow 27.6 47.6
arithmetic normal 7.7 11.6
fixnum slow 8.1 14.1
arithmetic normal 2.1 3.3
local function n/a 1.1 1.9
calls
------
takf n/a 4.3 6.7
(with funcalls)
------
takl slow 23.1 39.3
(with lists) normal 9.0 14.2
takl 6.4 10.5
(local functions)
Key: slow = (sstatus translink nil), fasl = (sstatus translink on)
n/a = doesn't make any difference how the links are set.
The generic example uses add1, sub1, lessp. All others use the
fixnum specific operations.
takf uses funcall rather than the normal way of function calling.
;;; ELISP/UCILISP
In Elisp, all final calls are turned into jumps. A tailrecursive
function does in fact turn into a loop. I think the R/UCI compiler does
the same, but I am not as familiar with at. (As you may know, the Elisp
compiler is a modified Utah PSL compiler from about a year ago.)
Elisp
(tak 18 12 6) 1.063 (0)
(takf 18 12 6) 2.094 (0)
R/UCI Lisp, NOUUO
(tak 18 12 6) .969 (0)
(takf 18 12 6) 3.157 (0)
-------
∂21-May-82 2048 Martin.Griss <Griss at UTAH-20> Latest PSL Tak times
Date: 21 May 1982 2115-MDT
From: Martin.Griss <Griss at UTAH-20>
Subject: Latest PSL Tak times
To: rpg at SU-AI
cc: griss at UTAH-20
We are now running V3 PSL on all machines (20, VAX and Apollo).
I attach following tiomes, tho am suprized that ARITH time went up.
May indicate other opts slipped in recent builds.
Latest PSL Times for TAK (the older JMC TAK)
As of 9:08pm Friday, 21 May 1982
Note that in V3 PSL, we have new tagging scheme (0 for POSINT, -1 for
NEGINT, so INUM times replace==are SYSLISP times]
For some reason, Generic ARITH times went up (?) will check.
Utah-20: PSL (TAKF, Inum) 443 ms
PSL (generic arith) 1936 ms [Was 1.672, need test INUM first?]
Fast Link LISP 1.6 990 ms
VAX-11/750:
PSL (TAKF,Inum) 1292 ms
PSL (generic) 7344 ms
Apollo/Domain
PSL (TAKF, Inum) 2932 ms
-------
LM-2 HIC
;; 2. TAK
(DEFUN TEST-TAK ()
(TIMING "TAK" (TAK 18. 12. 6.)))
;; Compiled: 2.905 seconds
;; Interpreted: 291 seconds
LM-2 HIC
;; 4A. TAKF (????)
;; Where did this come from?
(DEFUN TEST-TAKF ()
(TIMING "TAKF" (TAKF 18. 12. 6.)))
;; Compiled: 4.446 seconds.
;; Interpreted: long.
InterLisp-10
TAK, normal compiled, Integer arith (swapping space low?)
tak(18,12,6) 13.288
tak(2018,2012,2006) 20.285
Block compiled
tak(18,12,6) 2.1534
tak(2018,2012,2006) 2.47575 and 6.2775 gc seconds (amortized over 4 runs)
RPG and Jim Bennett
COMMENT ⊗ VALID 00005 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 00003 ∂06-Jul-82 1724 ARPAVAX.fateman at Berkeley
C00006 00004 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00011 00005 LM-2
C00012 ENDMK
C⊗;
; SAIL
(fasload dderiv)
(timit)
Timing performed on Friday 07/16/82 at 10:26:07.
Cpu Time = 3.285
Elapsed Time = 320.116665
Wholine Time = 45.9
GC Time = 19.913
Load Average Before = 3.65508044
Load Average After = 5.23962355
Average Load Average = 4.447352
NIL
Timing performed on Friday 07/16/82 at 10:43:01.
Cpu Time = 3.288
Elapsed Time = 202.766666
Wholine Time = 45.233333
GC Time = 19.452
Load Average Before = 1.68017912
Load Average After = 2.96003354
Average Load Average = 2.32010633
NIL
Timing performed on Friday 07/16/82 at 10:46:59.
Cpu Time = 3.282
Elapsed Time = 156.6
Wholine Time = 45.9166665
GC Time = 19.847
Load Average Before = 2.6731608
Load Average After = 2.91310465
Average Load Average = 2.79313272
NIL
∂06-Jul-82 1724 ARPAVAX.fateman at Berkeley
Date: 6 Jul 1982 17:02:05-PDT
From: ARPAVAX.fateman at Berkeley
To: rpg@su-ai
Cc: ARPAVAX.jkf@Berkeley
dderiv under the same conditions, 30.8 sec, 17.28 in GC.
[same conditions =
I just ran DERIV; Franz Lisp opus 38.20 on a vax 11/780 running with
a load average of between .5 and .8 (light). Recorded time 27 seconds
of which 16 were in garbage collection.
The only change to the file was to declare (localf der1 deriv).]
∂06-Jul-82 1740 ARPAVAX.fateman at Berkeley
Date: 6 Jul 1982 17:35:21-PDT
From: ARPAVAX.fateman at Berkeley
To: rpg@su-ai
Cc: ARPAVAX.jkf@Berkeley
jkf reminded me to do (sstatus translink on) to get faster times,
so with that, on a 780:
deriv = 25,2, 16.9 of which is GC
dderiv = 27.4, 17.6 of which is GC
fdderiv requires subrcall which we don't have exactly. I haven't
looked to see how funcall can work instead.
∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
Date: 16 Jul 1982 0003-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: DERIV, DDERIV, FDDERIV results
To: rpg at SU-AI
Results for DERIV, DDERIV, FDDERIV for UCILISP (UT's version).
All timings are on SRI-AI's 2060 with load average around 0.2.
Notes on coding of the programs:
UCILISP open codes MAPCAR if the function is specified by a
LAMBDA expression but does not if the function is a defined function.
Therefore, (MAPCAR 'FOO BAR) was translated into (MAPCAR (FUNCTION
(LAMBDA (X) (FOO X))) BAR) to keep in the spirit of the open coded
version sent out.
DDERIV and FDDERIV involve calling a function which is the value of
a local variable. In UCILISP this may be done by simply calling
(FOO ...) where FOO is the local variable rather than fooling with
FUNCALL or SUBRCALL. This format handles both cases. With (NOUUO
NIL), these function calls do not become direct jumps (because the
value may change next time).
There was a slight problem in having the compiler produce SUBR code
to be stored under a different property (DERIV). It could be done
but not conveniently. So I just compiled the code as SUBR's and
editted the LAP code to make it load onto the DERIV property.
DDERIV and FDDERIV were the version that had the (CONS 'TIMES A) in
the definition for TIMES.
The loop was a PROG which had 5 calls to DERIV and looped 1000 times.
The function that did this was compiled to minimize the overhead.
In order to compute the overhead, I had a similar loop that called
a dummy function that just returned its arguments. Its cost was
about 0.21 seconds for the (NOUUO T) case and about 0.04 seconds
for the (NOUUO NIL) case. I did NOT subtract these out in the following
results (but I feel they should be).
Each test run produced about 265000 conses and I had about 150000 free words.
I did a GC before each run to keep things as constant as possible.
Function (NOUUO T) (NOUUO NIL)
DERIV 14.879-0.875 (.213) 4.451-0.868 (.043)
DDERIV 16.250-0.856 (.198) 4.983-0.855 (.044)
FDDERIV 16.073-0.873 (.211) 4.857-0.871 (.028)
DDERIV* 18.171-1.742 (.212) 6.091-1.717 (.043)
The format of the times are
total-gc (dummy)
where total is the total CPU time (including GC), GC is the amount used for
garbage collection and dummy is the amount of time used by the dummy loop. I
believe the clock ticks about every 0.015 seconds which explains the
difference between the .028 and .044 dummy times (one less tick).
Explanation of results:
I believe the second and third to be slower because the property list of
the variable (whose value was the property name) had to be searched twice,
first for a function property and then for the value of the variable.
Then, for the DDERIV case, another property list had to be searched to
find the function definition.
The DDERIV* case is one in which a FUNCALL is used. In UCILISP this
results in an extra CONS and a call to APPLY* which then does everything
done above. As you can see, it is slower.
-------
;;;LM-2
;; 8. DDERIV
(DEFUN TEST-DDERIV ()
(TIMING "DDERIV" (RUN)))
;; Compiled: 25.4 β⎇conds.
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 ENDMK
C⊗;
;;; SAIL
(fasload fprint)
(timit)
Timing performed on Monday 09/13/82 at 11:56:15.
Cpu Time = 0.901
Elapsed Time = 3.53333333
Wholine Time = 1.83333333
GC Time = 0.0
Load Average Before = 2.06104112
Load Average After = 2.0700469
Average Load Average = 2.065544
NIL
Timing performed on Monday 09/13/82 at 11:56:23.
Cpu Time = 0.897
Elapsed Time = 4.55
Wholine Time = 1.8
GC Time = 0.0
Load Average Before = 2.02221072
Load Average After = 2.00235736
Average Load Average = 2.01228404
NIL
Timing performed on Monday 09/13/82 at 11:56:31.
Cpu Time = 0.888
Elapsed Time = 6.5
Wholine Time = 2.5
GC Time = 0.475
Load Average Before = 1.99930274
Load Average After = 1.97900426
Average Load Average = 1.9891535
NIL
COMMENT ⊗ VALID 00006 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 00003 ELISP/UCILISP
C00005 00004 T/UCILISP
C00006 00005 LM-2
C00007 00006 ∂03-Oct-82 2050 James Bennett <csd.Bennett at SU-SCORE> initial timings
C00010 ENDMK
C⊗;
;;; SAIL
(timit)
success in 2005 trials
Cpu Time = 8.736
Elapsed Time = 15.4666667
Wholine Time = 12.85
GC time = 0.421
Load Average Before = 0.560385704
Load Average After = 0.62576735
NIL
success in 2005 trials
Cpu Time = 8.762
Elapsed Time = 21.0833333
Wholine Time = 12.9333333
GC time = 0.422
Load Average Before = 0.62777853
Load Average After = 0.77028763
NIL
success in 2005 trials
Cpu Time = 8.758
Elapsed Time = 22.3166666
Wholine Time = 13.2333333
GC time = 0.422
Load Average Before = 0.85665059
Load Average After = 0.982417345
NIL
;;; PUZZLE (model B)
success in 2005 trials
Cpu Time = 7.865
Elapsed Time = 14.5666667
Wholine Time = 11.8333334
GC time = 0.0
Load Average Before = 0.63950753
Load Average After = 0.70015371
NIL
;;; ELISP/UCILISP
Elisp: 25.133 sec.
R/UCI Lisp: 75.622 sec.
R/UCI Lisp with NOUUO NIL: 25.840 sec.
;;; T/UCILISP
∂10-May-82 2101 Mabry Tyson <Tyson at SRI-AI> UCI Lisp on Basket Puzzle
Date: 10 May 1982 2055-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: UCI Lisp on Basket Puzzle
To: rpg at SU-AI
Results on the Basket Puzzle Benchmark for UCI-Lisp (version from UTexas-20,
tests run on SRI-AI 2060).
Compiled, slow links: 85.804 seconds (no GC)
Compiled, fast links: 23.966 seconds (no GC)
-------
;;; LM-2
;; 6. PUZZLE
(DEFUN TIME-PUZZLE ()
(TIMING "PUZZLE" (START)))
;; Compiled: 59.0 Seconds
∂03-Oct-82 2050 James Bennett <csd.Bennett at SU-SCORE> initial timings
Date: 3 Oct 1982 2046-PDT
From: James Bennett <csd.Bennett at SU-SCORE>
Subject: initial timings
To: rpg at SU-AI
Stanford-Phone: (415) 497-2225
Home-Phone: (415) 322-2233
Dick,
I got it to work. You are right about Interlisp array indicies
starting at 1 rather than 0. I thought that the ADD1's would unduly
increase the running times but I think that this effect is in the noise
after looking at the following results. First I block compiled the functions,
timed start, and then did the same with the uncompiled versions. As
you can see below, compiling had little effect. I would say that array
access sucks in Interlisp. I suggest that you run the breakdown package
on this function just to see were it is spending its time, jim
NIL
←(TIME (START) 1 0] ; bcompl'd version
success in 2005 trials
0 conses
1481.138 seconds
2782.667 seconds, real time
NIL
←LOAD(PUZZLE]
FILE CREATED 3-Oct-82 13:00:20
PUZZLECOMS
(START redefined)
(DEFINE-ARRAY redefined)
collecting arrays
7820, 10380 free cells
<CSD.BENNETT>PUZZLE..10
←REDO TIME ; expr version
success in 2005 trials
0 conses
1481.692 seconds
2397.734 seconds, real time
NIL
←PL START
CODE : #176777
EXPR : (LAMBDA NIL (& 0) --)
←UNSAVEDEF(START CODE]
CODE
←REDO TIME
success in 2005 trials
0 conses
1479.684 seconds
2426.698 seconds, real time
NIL
←DRIBBLE]
-------
COMMENT ⊗ VALID 00012 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00009 00003 Franz on a 780 (Old version superceded later in this file)
C00010 00004 Multics
C00012 00005 780 Franz
C00014 00006 UTEXAS20 running UCI-LISP
C00019 00007 UTLISP 5.1
C00024 00008 ELISP/UCILISP
C00026 00009 Texas UCILISP
C00030 00010 Franz on 11/780 and 11/750
C00035 00011 ∂06-May-82 0129 Mabry Tyson <Tyson at SRI-AI> FRPOLY results for UCI Lisp
C00038 00012 LM-2
C00040 ENDMK
C⊗;
;;; SAIL
(setup)
(Z 1 1.0 0 (Y 1 1.0 0 (X 1 1.0 0 1.0)))
(setq base 10. ibase 10.)
10.
(bench 2.)
(POWER= 2. (7.0E-3 0.0 0.0166666666) (6.0E-3 0.0 0.0166666666) (7.0E-3 1.0E-3 0.05))
(bench 5.)
(POWER= 5. (0.146 0.096 0.183333334) (0.171 0.094 0.283333335) (0.14 0.09 0.216666667))
(bench 10.)
(POWER= 10. (1.132 0.588 2.4) (5.145 4.055 9.35) (2.399 1.842 4.75))
(bench 15.)
(POWER= 15. (5.884 2.235 8.9166666) (41.611 30.642 72.0) (20.687 16.999 47.8166666))
(bench 2.)
(POWER= 2. (5.0E-3 0.0 0.0) (5.0E-3 0.0 0.0) (5.0E-3 0.0 0.0))
(bench 5.)
(POWER= 5. (0.048 0.0 0.083333333) (0.076 0.0 0.15) (0.231 0.182 0.383333333))
(bench 10.)
(POWER= 10. (0.538 0.0 0.983333334) (1.881 0.82 3.45) (1.311 0.766 2.06666666))
(bench 15.)
(POWER= 15. (4.457 0.825 7.0833333) (29.15 18.186 57.05) (17.037 13.319 29.8833334))
(bench 2)
(POWER= 2. (5.0E-3 0.0 0.0166666666) (5.0E-3 0.0 0.033333333) (6.0E-3 0.0 0.0166666666))
(bench 5)
(POWER= 5. (0.049 0.0 0.1) (0.077 0.0 0.066666666) (0.236 0.185 0.4))
(bench 10.)
(POWER= 10. (0.542 0.0 1.01666667) (1.903 0.826 3.26666668) (1.33 0.776 2.41666666))
(bench 15.)
(POWER= 15. (4.506 0.831 9.2333333) (29.242 18.198 53.9) (16.88 13.226 28.8833334))
;;; Model B
(fasload frpoly)
(bench 2)
TEST1
Timing performed on Tuesday 04/26/83 at 12:36:05.
Cpu (- GC) Time = 5.0E-3
Elapsed Time = 0.033333333
Wholine Time = 0.0166666666
GC Time = 0.0
Load Average Before = 1.07315445
Load Average After = 1.07362497
Average Load Average = 1.07338971
TEST2
Timing performed on Tuesday 04/26/83 at 12:36:08.
Cpu (- GC) Time = 5.0E-3
Elapsed Time = 0.0166666666
Wholine Time = 0.0166666666
GC Time = 0.0
Load Average Before = 1.0696851
Load Average After = 1.06967664
Average Load Average = 1.06968087
TEST3
Timing performed on Tuesday 04/26/83 at 12:36:11.
Cpu (- GC) Time = 4.0E-3
Elapsed Time = 0.0166666666
Wholine Time = 0.0166666666
GC Time = 0.0
Load Average Before = 1.07251835
Load Average After = 1.07275367
Average Load Average = 1.07263601
NIL
(bench 5)
TEST1
Timing performed on Tuesday 04/26/83 at 12:36:20.
Cpu (- GC) Time = 0.042
Elapsed Time = 0.516666666
Wholine Time = 0.0166666666
GC Time = 0.0
Load Average Before = 1.05037117
Load Average After = 1.06493556
Average Load Average = 1.05765337
TEST2
Timing performed on Tuesday 04/26/83 at 12:36:21.
Cpu (- GC) Time = 0.067
Elapsed Time = 3.03333333
Wholine Time = 1.03333333
GC Time = 0.389
Load Average Before = 1.07364166
Load Average After = 1.13156891
Average Load Average = 1.10260528
TEST3
Timing performed on Tuesday 04/26/83 at 12:36:25.
Cpu (- GC) Time = 0.042
Elapsed Time = 0.083333333
Wholine Time = 0.083333333
GC Time = 0.0
Load Average Before = 1.13101137
Load Average After = 1.1309315
Average Load Average = 1.13097143
NIL
(bench 10.)
TEST1
Timing performed on Tuesday 04/26/83 at 12:37:06.
Cpu (- GC) Time = 0.467
Elapsed Time = 6.81666666
Wholine Time = 1.93333334
GC Time = 0.785
Load Average Before = 1.0520922
Load Average After = 1.17209852
Average Load Average = 1.11209536
TEST2
Timing performed on Tuesday 04/26/83 at 12:37:14.
Cpu (- GC) Time = 0.926
Elapsed Time = 56.9166665
Wholine Time = 12.4833333
GC Time = 5.941
Load Average Before = 1.1852001
Load Average After = 2.3180405
Average Load Average = 1.7516203
TEST3
Timing performed on Tuesday 04/26/83 at 12:38:14.
Cpu (- GC) Time = 0.47
Elapsed Time = 27.7833333
Wholine Time = 5.8833333
GC Time = 2.979
Load Average Before = 2.3805095
Load Average After = 2.8017373
Average Load Average = 2.5911234
NIL
(bench 15.)
TEST1
Timing performed on Tuesday 04/26/83 at 12:38:55.
Cpu (- GC) Time = 3.145
Elapsed Time = 48.4333334
Wholine Time = 12.5666667
GC Time = 4.824
Load Average Before = 2.92283165
Load Average After = 3.26940846
Average Load Average = 3.09612006
TEST2
Timing performed on Tuesday 04/26/83 at 12:39:47.
Cpu (- GC) Time = 9.434
Elapsed Time = 201.45
Wholine Time = 94.766666
GC Time = 50.48
Load Average Before = 3.29244137
Load Average After = 3.04327726
Average Load Average = 3.16785932
TEST3
Timing performed on Tuesday 04/26/83 at 12:43:11.
Cpu (- GC) Time = 3.159
Elapsed Time = 134.483334
Wholine Time = 81.333333
GC Time = 48.86
Load Average Before = 3.01823843
Load Average After = 2.42033207
Average Load Average = 2.71928525
NIL
;;; Franz on a 780 (Old version superceded later in this file)
;;; FPOLY compiled times (load = 3.5)
(setup)
(Z 1 1.0 0 (Y 1 1.0 0 (X 1 1.0 0 1.0)))
(bench 2)
(POWER= 2 (0.017 0.0) (0.017 0.0) (0.016 0.0))
(bench 5)
(POWER= 5 (0.116 0.0) (1.334 1.084) (0.15 0.0))
(bench 10)
(POWER= 10 (2.534 1.8) (19.733 17.151) (8.983 7.901))
(bench 15)
(POWER= 15 (16.65 8.832) (112.516 89.298) (63.9 56.749))
;;; Multics
(setup)
(z 1 1.0 0 (y 1 1.0 0 (x 1 1.0 0 1.0)))
(bench 2)
(power= 2 (0.016692 0.0) (0.015114 0.0) (0.015725 0.0))
(bench 5)
(power= 5 (0.150491 0.0) (0.212428 0.0) (0.154568 0.0))
(bench 10) ;=8
(power= 10 (0.968238 0.184816) (1.71576 0.389726) (0.99761099 0.187837))
(bench 10.) ;decimal
(power= 12 (2.000796 0.405341) (3.569996 0.880229) (1.883108 0.231459))
(bench 15) ;octal = 13.
(power= 15 (6.563067 1.148998) (13.168704 2.515469) (6.694873 1.155386))
(bench 15.) ;decimal
(power= 17 (12.532608 1.85896) (27.568518 5.391129) (12.636826 1.860995))
(quit)
hmu
Multics 35.0a, load 42.0/120.0; 42 users, 27 interactive, 12 daemons.
Absentee users 1/3 (+2 FG)
;;; 780 Franz
Here are the results or running the pairs benchmark on Franz Lisp on
a VAX 11/780 runing Berkeley 4BSD Unix. The load average was less
than one when the timing was done. These results supersede the timings
you have which were made by us in March.
-> (setup)
(z 1 1.0 0 (y 1 1.0 0 (x 1 1.0 0 1.0)))
-> (bench 2)
(power= 2 (0.0167 0.0) (0.0333 0.0) (0.0 0.0))
-> (bench 5)
(power= 5 (0.15 0.0) (0.75 0.4333) (0.3833 0.2166))
-> (bench 10)
(power= 10 (2.8167 1.05) (8.2333 3.3) (3.2 1.2333))
-> (bench 15)
(power= 15 (18.2333 5.35) (92.0333 41.6333) (18.8 5.1333))
->
script done on Fri Apr 24 06:07:48 1981
;;; UTEXAS20 running UCI-LISP
(Times are in the form R+G where R is the runtime (not including GC time)
and G is the GC time. All times are in seconds. "Interp" means interpreted,
"Slow" means compiled but using UUO-links, "Fast" means compiled with the UUO
links replaced by direct jumps.)
Processor
Program KL-2060 KI-1060
Interp Slow Fast Interp Slow Fast
FRPOLY:
Free: 100000. 75000.
(bench 0.719+0 0.142+0 0.043+0 2.627+0 0.576+0 0.181+0
2) 0.677+0 0.142+0 0.047+0 2.619+0 0.545+0 0.168+0
First 0.677+0 0.141+0 0.042+0 2.698+0 0.580+0 0.166+0
result 0.687+0 0.140+0 0.043+0 0.612+0 0.155+0
----------------------------------------------------------------------
Third 0.706+0 0.162+0 0.063+0 2.585+0 0.630+0 0.256+0
result 0.830+0 0.164+0 0.063+0 2.798+0 0.610+0 0.227+0
0.702+0 0.162+0 0.062+0 2.733+0 0.695+0 0.252+0
0.700+0 0.162+0 0.065+0 0.593+0 0.215+0
======================================================================
(bench 5.88+0 1.166+0 0.343+0 22.25+0 4.384+0 1.451+0
5) 5.696+0 1.142+0 0.355+0 21.87+0 4.462+0 1.297+0
First 5.706 1.146+0 0.338+0 4.719+0 1.500+0
result 1.18+0 0.351+0
----------------------------------------------------------------------
Third 5.891+0 1.343+0 0.523+0 23.04+0 4.964+0 2.097+0
result 5.880+0 1.383+0 0.51+0 21.64+0 5.084+0 2.065+0
5.884+0 1.345+0 0.522+0 5.093+0 2.048+0
1.341+0 0.514+0
======================================================================
(bench 122.2+1.1 25.48+1.02 8.63+1.04 -- -- 31.91+2.12
10) 25.14+0.98 8.42+1.02
First 25.53+1.03 8.47+1.01
----------------------------------------------------------------------
Third 126.4+2.2 28.17+2.02 11.57+2.04 -- -- 39.07+6.07
result 28.26+2.03 11.54+2.04
28.18+2.04 11.28+1.98
======================================================================
(bench -- 39.22+2.16 12.59+2.00 -- -- --
15) 12.98+2.06
First
----------------------------------------------------------------------
Third -- 43.46+3.08 17.22+3.02 -- -- --
result 17.58+3.05
======================================================================
Note: The results referred to as the first result is the result obtained
as the first value returned by BENCH. This is the value computed using
integer coefficients. The result referred to as the third result is the
third value returned by BENCH (for real number coefficients). UCI Lisp
does not have the bignum package so it could not compute the second
result returned by the BENCH routine.
-------
;;; UTLISP 5.1
Following are the results for FRPOLY under UTLISP 5.1. The runs at
75000 (octal) were run interactively; the remainder were submitted
as batch jobs. "runtime" does NOT include "gctime".
Interpreted:
bench 2: (runtime+gctime)
R: 1.168+0 1.168+0 1.149+0 1.147+0
R2: 1.181+0 1.162+0 1.171+0 1.174+0
R3: 1.175+0 1.170+0 1.171+0 1.179+0
bench 5: (runtime over gctime)
R: 9.910 9.917 9.868 9.904
.156 .145 .152 .148
R2: 5.237 5.261 5.245 5.237
.162 .156 .157 .156
R3: 9.930 9.899 9.960 9.927
.323 .315 .311 .300
bench 10:
R: 213.160
4.205
R2: 7.136
.168
R3: 213.650
3.994
bench 2 and bench 5 were run at a field length (= core size) of
75000 (octal) words with: free space of 7500. words
full space of 2583. words
bench 2 required no garbage collections; bench 3 required 4 garbage
collections for each run.
bench 10 was run at a field length of 200000 (octal) words with:
free space of 41706. words
full space of 6685. words
bench 10 required 38 garbage collections.
For obvious reasons, I did not run bench 15.
Compiled:
bench 2:
R: .173 .139 .153 .149
0. 0. .108 0.
R2: .165 .167 .156 .150
0. .115 0. 0.
R3: .155 .154 .165 .183
0. 0. 0. 0.
bench 5:
R: 1.406 1.361 1.353 1.327
.328 .356 .366 .385
R2: .897 .872 .857 .861
.159 .253 .257 .260
R3: 1.430 1.372 1.382 1.375
.325 .395 .396 .269
bench 10:
R: 30.043 30.009 30.016
3.989 3.866 4.010
R2: 1.219 1.172 1.218
.143 .179 .155
R3: 30.495 30.509 30.528
4.015 3.896 3.916
bench 15:
R: 46.046 46.030
7.346 7.330
R2: 2.120 2.122
.171 .174
R3: 46.945 46.736
7.077 7.264
bench 2 and bench 5 were run at a field length of 75000 (octal)
words with: free space of 14177. words
full space of 1554. words
bench 2 required 0 or 1 garbage collections per run; bench 5
required 7 to 8 garbage collections per run.
bench 10 and bench 15 were run at a field length of 200000 (octal)
words with: free space of 42913. words
full space of 6859. words
bench 10 required 37 garbage collections per run; bench 15 required
63 garbage collections.
As you can see from the R2 results, there are times when a 60 bit word
size can come in handy.
-------
;;; ELISP/UCILISP
Note that in BENCH, the middle numbers are missing, as we don't have
BIGNUM's. All numbers are in seconds. The ones in () are for GC.
In Elisp, all final calls are turned into jumps. A tailrecursive
function does in fact turn into a loop. I think the R/UCI compiler does
the same, but I am not as familiar with at. (As you may know, the Elisp
compiler is a modified Utah PSL compiler from about a year ago.)
Elisp
(bench 10) .893 (0) 1.018 (0)
(bench 15) 4.919 (.809) 4.416 (.221)
R/UCI Lisp, NOUUO
(bench 10) 1.137 (.276) 2.658 (1.404)
(bench 15) 7.162 (2.926) 20.208 (14.453)
-------
;;; Texas UCILISP
∂06-May-82 0129 Mabry Tyson <Tyson at SRI-AI> FRPOLY results for UCI Lisp
Date: 6 May 1982 0127-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: FRPOLY results for UCI Lisp
To: rpg at SU-AI
Results on FRPOLY for UCILISP (version from University of Texas at Austin
running on SRI-AI TOPS-20). Running with the TOPS-10/TOPS-20 compatibility
package.
Notes relevent to this problem: UCILSP does not have bignums. (The hooks are
there but I know of no source that uses them.) All arithmetic operations
are generic and are NOT compiled in-line. The times reported are CPU times
and the first time (the total) includes the second time (the GC time).
The only non-syntactic change to the source was to change the divisor for
the time computation from 1000000.0 to 1000.0 since UCILSP reports times in
milliseconds.
Interpreted (Macros expanded once only):
(bench 2)
(POWER= 2 (0.58200000 0.00000000) ? (0.67300000 0.00000000))
(bench 5)
(POWER= 5 (6.0660000 0.00000000) ? (6.1940000 0.00000000))
Compiled without fast links (and that includes calls to arithmetic functions):
Interpreted (Macros expanded once only):
(bench 2)
(POWER= 2 (0.58200000 0.00000000) ? (0.67300000 0.00000000))
(bench 5)
(POWER= 5 (6.0660000 0.00000000) ? (6.1940000 0.00000000))
Compiled without fast links (and that includes calls to arithmetic functions):
(bench 2)
(POWER= 2 (0.84000000E-1 0.00000000) ? (0.90000000E-1 0.00000000))
(bench 5)
(POWER= 5 (0.93900000 0.00000000) ? (1.0160000 0.00000000))
(bench 10)
(POWER= 10 (19.273000 1.1050000) ? (19.655000 1.0580000))
(bench 15)
(POWER= 15 (31.048000 2.1530000) ? (33.469000 3.2140000))
Compiled with fast links:
(bench 2)
(POWER= 2 (0.18000000E-1 0.00000000) ? (0.23000000E-1 0.00000000))
(bench 5)
(POWER= 5 (0.20800000 0.00000000) ? (0.27900000 0.00000000))
(bench 10)
(POWER= 10 (5.5870000 1.0570000) ? (6.3900000 1.0760000))
(bench 15)
(POWER= 15 (9.1310000 2.0910000) ? (11.560000 3.1940000))
-------
;;; Franz on 11/780 and 11/750
∂25-May-82 0907 jkf@ucbkim at Berkeley frpoly benchmark, complete results
Date: 25 May 1982 09:03:10-PDT
From: jkf@ucbkim at Berkeley
Mail-From: ucbkim received by UCBVAX at 25-May-82 08:46:04-PDT (Tue)
Date: 25-May-82 08:52:21-PDT (Tue)
From: jkf@ucbkim
Subject: frpoly benchmark, complete resu` ts
Via: ucbkim.EtherNet (V3.100 [3/27/82]); 25-May-82 08:52:27-PDT (Tue)
Via: ucbvax.EtherNet (V3.100 [3/27/82]); 25-May-82 08:46:04-PDT (Tue)
To: rpg@su-ai
Cc: jkf@fateman@Berkeley
frpoly benchmark -[Tue May 25 08:51:42 1982 by jkf]-
Results for Franz Lisp Opus 38.18, and compiler Liszt 8.07
11/780
Slow links:
(power= 2 (0.05 0.0) (0.06666666666666667 0.0) (0.06666666666666667 0.0))
(power= 5 (0.6 0.0) (1.18333 0.4166666666666667) (0.9833333333333333 0.4))
(power= 10 (7.6666667 0.8833) (14.866667 3.83333) (8.6166667 1.433333333333))
(power= 15 (52.51666666666667 5.316666667) (132.8 43.0) (54.2666667 6.95))
Normal links:
(power= 2 (0.01666667 0.0) (0.01666666667 0.0) (0.03333333333333333 0.0))
(power= 5 (0.2 0.0) (0.3833333333333333 0.0) (0.2166666666666667 0.0))
(power= 10 (2.333333333333333 0.0) (8.0 2.266666666666667) (2.6 0.0))
(power= 15 (20.6 4.016666666667) (86.5 30.3833333) (25.0833333 6.766666667))
Local Functions:
(power= 2 (0.01666666667 0.0) (0.016666667 0.0) (0.01666666666666667 0.0))
(power= 5 (0.15 0.0) (0.66666667 0.36666667) (0.51666667 0.3333333333333333))
(power= 10 (2.6 0.8333333333333333) (8.866667 3.7) (3.85 1.833333333333333))
(power= 15 (18.48333333 5.6333333) (93.866667 41.75) (21.7 6.966666666667))
11/750
Slow links:
(power= 2 (0.0833333333333 0.0) (0.116666666667 0.0) (0.08333333333333 0.0))
(power= 5 (0.933333333 0.0) (1.8 0.56666666667) (1.6166666667 0.633333333333))
(power= 10 (12.06666667 1.3666666667) (22.26667 5.93333) (13.86667 2.8833333))
(power= 15 (82.5666667 9.3833333) (202.683333 67.46666667) (86.83333 11.2167))
Normal links:
(power= 2 (0.05 0.0) (0.03333333333333333 0.0) (0.03333333333333333 0.0))
(power= 5 (0.35 0.0) (1.18333333 0.566667) (1.0166667 0.6666666666666667))
(power= 10 (5.3666667 1.383333) (14.95 5.816667) (7.266666666666667 2.95))
(power= 15 (37.233333 9.1166667) (155.45 67.15) (41.46666666666667 11.0))
Local functions:
(power= 2 (0.0333333 0.0) (0.03333333333333333 0.0) (0.01666666666666667 0.0))
(power= 5 (0.2666666666666667 0.0) (0.4833333333333333 0.0) (0.3 0.0))
(power= 10 (3.15 0.0) (11.81666666666667 3.516666666666667) (3.466666666666667 0.0))
(power= 15 (29.46666666666667 6.65) (129.5666666666667 48.21666666666667) (36.7 11.21666666666667))nil
Slow links means (sstatus translink nil)
Fast links means (sstatus translink t)
Local functions means that certain functions are declared to be local
to this file.
∂06-May-82 0129 Mabry Tyson <Tyson at SRI-AI> FRPOLY results for UCI Lisp
Date: 6 May 1982 0127-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: FRPOLY results for UCI Lisp
To: rpg at SU-AI
Results on FRPOLY for UCILISP (version from University of Texas at Austin
running on S TOPS-20). Running with the TOPS-10/TOPS-20 compatibility
package.
Notes relevent to this problem: UCILSP does not have bignums. (The hooks are
there but I know of no source that uses them.) All arithmetic operations
are generic and are NOT compiled in-line. The times reported are CPU times
and the first time (the total) includes the second time (the GC time).
The only non-syntactic change to the source was to change the divisor for
the time computation from 1000000.0 to 1000.0 since UCILSP reports times in
milliseconds.
Interpreted (Macros expanded once only):
(bench 2)
(POWER= 2 (0.58200000 0.00000000) ? (0.67300000 0.00000000))
(bench 5)
(POWER= 5 (6.0660000 0.00000000) ? (6.1940000 0.00000000))
Compiled without fast links (and that includes calls to arithmetic functions):
(bench 2)
(POWER= 2 (0.84000000E-1 0.00000000) ? (0.90000000E-1 0.00000000))
(bench 5)
(POWER= 5 (0.93900000 0.00000000) ? (1.0160000 0.00000000))
(bench 10)
(POWER= 10 (19.273000 1.1050000) ? (19.655000 1.0580000))
(bench 15)
(POWER= 15 (31.048000 2.1530000) ? (33.469000 3.2140000))
Compiled with fast links:
(bench 2)
(POWER= 2 (0.18000000E-1 0.00000000) ? (0.23000000E-1 0.00000000))
(bench 5)
(POWER= 5 (0.20800000 0.00000000) ? (0.27900000 0.00000000))
(bench 10)
(POWER= 10 (5.5870000 1.0570000) ? (6.3900000 1.0760000))
(bench 15)
(POWER= 15 (9.1310000 2.0910000) ? (11.560000 3.1940000))
-------
;;;LM-2
;; 3. FRPOLY
(DEFUN TEST-FRPOLY (N)
(LET (START RES1 RES2 RES3)
(WITHOUT-INTERRUPTS
(SETQ START (TIME:MICROSECOND-TIME))
(PEXPTSQ R N)
(SETQ RES1 (TIME:MICROSECOND-TIME))
(PEXPTSQ R2 N)
(SETQ RES2 (TIME:MICROSECOND-TIME))
(PEXPTSQ R3 N)
(SETQ RES3 (TIME:MICROSECOND-TIME)))
(FORMAT T "~%Power= ~D. ~20T~S ~32T~S ~44T~S" N
(// (- RES1 START) 1000000.0)
(// (- RES2 RES1) 1000000.0)
(// (- RES3 RES2) 1000000.0))))
;; Compiled results
;; Power= 2. 0.016191 0.020865 0.021139
;; Power= 2. 0.01614 0.020716 0.020233
;; Power= 5. 0.175673 0.251539 0.236832
;; Power= 5. 0.20282 0.251422 0.236561
;; Power= 10. 2.202732 3.7338 3.143525
;; Power= 10. 2.293053 3.520599 2.725204
;; Power= 15. 18.589147 32.037923 22.587246
;; Power= 15. 18.547342 30.895854 22.432256
COMMENT ⊗ VALID 00006 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 ELISP/UCILISP
C00003 00003 SAIL
C00004 00004 Texas UCILISP
C00006 00005 ∂08-May-82 2148 Kim.jkf at Berkeley updated mas benchmark results
C00007 00006 Utah results
C00010 ENDMK
C⊗;
;;; ELISP/UCILISP
Elisp: 2.389 sec.
R/UCI Lisp: 12.816 sec.
R/UCI Lisp with NOUUO NIL: 3.886 sec.
;;;SAIL
(timit)
(RUNTIME 3.227)
(GCTIME 0.0)
T
(timit)
(RUNTIME 3.231)
(GCTIME 0.0)
T
(timit)
(RUNTIME 3.226)
(GCTIME 0.0)
T
(timit)
(RUNTIME 3.241)
(GCTIME 0.0)
T
;;; Texas UCILISP
∂10-May-82 1917 Mabry Tyson <Tyson at SRI-AI> MAS timings for UCI-Lisp
Date: 10 May 1982 1913-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: MAS timings for UCI-Lisp
To: rpg at SU-AI
Timings for the MAS benchmark for UCI-Lisp (version from UTexas-20, run
on SRI-AI):
(MAS L18 L12 L6)
Compiled, slow links ((NOUUO T)) 15.849 seconds
Compiled, fast links ((NOUUO NIL)) 3.633 seconds
-------
∂08-May-82 2148 Kim.jkf at Berkeley updated mas benchmark results
Date: 8 May 1982 21:41:30-PDT
From: Kim.jkf at Berkeley
To: rpg@su-ai
Subject: updated mas benchmark results
Cc: Kim.fateman@Berkeley
I ran it with local functions and here are the complete results:
mas benchmark (tak benchmark using tak0 through tak99)
Lisp Opus 38.16,
Liszt 8.06
780 750
slow links 13.26 19.17
normal links 3.62 5.09
local functions 1.7 2.7
slow links = translink nil, fast links = translink on
; Utah results
∂22-May-82 2336 Martin.Griss <Griss at UTAH-20> MAS times
Date: 23 May 1982 0004-MDT
From: Martin.Griss <Griss at UTAH-20>
Subject: MAS times
To: rpg at SU-AI
cc: griss at UTAH-20
ON version 3 PSL:
DEC-20, 2.568 secs
VAX/750 11.59 secs
Will look at see if I missed anything. What do you expect?
-------
∂18-Jul-82 0719 Martin.Griss <Griss at UTAH-20> [Martin.Griss <Griss at UTAH-20>: MAS times]
Date: 18 Jul 1982 0815-MDT
From: Martin.Griss <Griss at UTAH-20>
Subject: [Martin.Griss <Griss at UTAH-20>: MAS times]
To: rpg at SU-AI
cc: griss at UTAH-20
What was "offgial" MAS times elsewhere.
---------------
Date: 23 May 1982 0004-MDT
From: Martin.Griss <Griss at UTAH-20>
Subject: MAS times
To: rpg at SU-AI
cc: griss
ON version 3 PSL:
DEC-20, 2.568 secs
VAX/750 11.59 secs
Will look at see if I missed anything. What do you expect?
-------
-------
COMMENT ⊗ VALID 00004 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00003 00003 ∂06-May-82 0128 Mabry Tyson <Tyson at SRI-AI> MAS results for UCI Lisp
C00005 00004 Franz
C00006 ENDMK
C⊗;
;;; SAIL
(timit)
(RUNTIME 0.855)
(GCTIME 0.0)
T
(timit)
(RUNTIME 0.846)
(GCTIME 0.0)
T
(timit)
(RUNTIME 0.848)
(GCTIME 0.0)
T
(timit)
(RUNTIME 0.865)
(GCTIME 0.0)
T
(timit)
(RUNTIME 0.875)
(GCTIME 0.0)
T
∂06-May-82 0128 Mabry Tyson <Tyson at SRI-AI> MAS results for UCI Lisp
Date: 6 May 1982 0126-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: MAS results for UCI Lisp
To: rpg at SU-AI
TAK program with 100 different TAKs for UCI Lisp (version from University of
Texas running on SRI-AI Tops-20 2060 with compatibility package.)
Notes on this program: The SUB1 is generic and is not compiled in-line.
(TAK 18. 12. 6.)
Interpreted: 22.485 seconds
Compiled, no fast links: 5.124 seconds
Compiled, fast links: 1.099 seconds
(The slowdown for the first two results may be due to increased time to search
the OBLIST. I don't know why the third time is 7% slower than the recursive
TAK. It might be due to increased swapping from other jobs??)
-------
;;; Franz
I think they mean TAKR here.
∂08-May-82 2148 Kim.jkf at Berkeley updated mas benchmark results
Date: 8 May 1982 21:41:30-PDT
From: Kim.jkf at Berkeley
To: rpg@su-ai
Subject: updated mas benchmark results
Cc: Kim.fateman@Berkeley
I ran it with local functions and here are the complete results:
mas benchmark (tak benchmark using tak0 through tak99)
Lisp Opus 38.16,
Liszt 8.06
780 750
slow links 13.26 19.17
normal links 3.62 5.09
local functions 1.7 2.7
slow links = translink nil, fast links = translink on
batch/now/do @cache.do
;TAK
.r plisp
T
(fasload tak)
43256.
(timit)
Cpu Time = 0.598
Elapsed Time = 1.18333334
Wholine Time = 0.93333333
GC time = 0.0
Load Average Before = 0.407542944
Load Average After = 0.439887762
NIL
(timit)
Cpu Time = 0.597
Elapsed Time = 0.9
Wholine Time = 0.85
GC time = 0.0
Load Average Before = 0.443776846
Load Average After = 0.466305614
NIL
(timit)
Cpu Time = 0.598
Elapsed Time = 1.11666666
Wholine Time = 0.95
GC time = 0.0
Load Average Before = 0.480769515
Load Average After = 0.52185619
NIL
↑C
↑C
.;SCCPP
.r plisp
T
(fasload sccpp)
42755.
(timit)
Cpu Time = 1.956
Elapsed Time = 86.766666
Wholine Time = 33.6833334
GC time = 20.93
Load Average Before = 0.62281585
Load Average After = 1.82679486
NIL
↑C
↑C
.;FRPOLY
.r plisp
T
(fasload frpoly)
;Loading DEFMAX 9844075.
(setup)
(Z 1. 1.0 0. (Y 1. 1.0 0. (X 1. 1.0 0. 1.0)))
(bench 2)
TEST1
Cpu Time = 6.0E-3
Elapsed Time = 0.0166666666
Wholine Time = 0.0166666666
GC time = 0.0
Load Average Before = 1.63969278
Load Average After = 1.63973677
TEST2
Cpu Time = 5.0E-3
Elapsed Time = 0.0166666666
Wholine Time = 0.0166666666
GC time = 2.0E-3
Load Average Before = 1.63237834
Load Average After = 1.63254535
TEST3
Cpu Time = 5.0E-3
Elapsed Time = 0.0166666666
Wholine Time = 0.0166666666
GC time = 0.0
Load Average Before = 1.61809087
Load Average After = 1.6181376
NIL
(bench 5)
TEST1
Cpu Time = 0.051
Elapsed Time = 0.1
Wholine Time = 0.1
GC time = 2.0E-3
Load Average Before = 1.59114468
Load Average After = 1.59290886
TEST2
Cpu Time = 0.078
Elapsed Time = 0.333333332
Wholine Time = 0.3
GC time = 0.093
Load Average Before = 1.58735871
Load Average After = 1.59104872
TEST3
Cpu Time = 0.051
Elapsed Time = 0.233333332
Wholine Time = 0.2
GC time = 0.087
Load Average Before = 1.58140123
Load Average After = 1.58026767
NIL
(bench 10.)
TEST1
Cpu Time = 0.549
Elapsed Time = 2.3
Wholine Time = 2.08333334
GC time = 0.576
Load Average Before = 1.5571512
Load Average After = 1.57628584
TEST2
Cpu Time = 1.083
Elapsed Time = 8.0333333
Wholine Time = 7.1333333
GC time = 2.653
Load Average Before = 1.57524002
Load Average After = 1.86861849
TEST3
Cpu Time = 0.557
Elapsed Time = 2.98333332
Wholine Time = 2.66666666
GC time = 0.891
Load Average Before = 1.88020575
Load Average After = 2.04178822
NIL
(bench 15.)
TEST1
Cpu Time = 3.746
Elapsed Time = 29.2333333
Wholine Time = 12.2
GC time = 2.001
Load Average Before = 2.1216352
Load Average After = 2.23069775
TEST2
Cpu Time = 10.997
Elapsed Time = 104.6
Wholine Time = 77.316667
GC time = 33.976
Load Average Before = 2.22474885
Load Average After = 1.78231514
TEST3
Cpu Time = 3.766
Elapsed Time = 72.283334
Wholine Time = 42.133333
GC time = 20.677
Load Average Before = 1.7809223
Load Average After = 1.87268043
NIL
↑C
↑C
.;TAKL
.r plisp
T
(fasload takl)
42379.
(timit)
Cpu Time = 3.483
Elapsed Time = 19.8333333
Wholine Time = 5.25
GC time = 0.0
Load Average Before = 1.70872498
Load Average After = 1.77099645
NIL
(timit)
Cpu Time = 3.478
Elapsed Time = 5.18333334
Wholine Time = 4.8833333
GC time = 0.0
Load Average Before = 1.76932609
Load Average After = 1.8595264
NIL
(timit)
Cpu Time = 3.479
Elapsed Time = 17.9833333
Wholine Time = 4.9
GC time = 0.0
Load Average Before = 1.86097574
Load Average After = 1.94217241
NIL
↑C
↑C
.;TAKR
.r plisp
T
(fasload takr)
46023.
(timit)
Cpu Time = 0.858
Elapsed Time = 1.73333333
Wholine Time = 1.66666667
GC time = 0.0
Load Average Before = 1.84821904
Load Average After = 1.8509841
NIL
(timit)
Cpu Time = 0.857
Elapsed Time = 2.28333333
Wholine Time = 1.95
GC time = 0.0
Load Average Before = 1.84288955
Load Average After = 1.8950212
NIL
(timit)
Cpu Time = 0.858
Elapsed Time = 1.95
Wholine Time = 1.83333333
GC time = 0.0
Load Average Before = 1.87972724
Load Average After = 1.89166927
NIL
↑C
↑C
.;PUZZLE
.r plisp
T
(fasload puzzle)
42775.
(timit)
success in 2005. trials
Cpu Time = 8.7
Elapsed Time = 15.0
Wholine Time = 12.4166666
GC time = 4.0E-3
Load Average Before = 1.78490114
Load Average After = 2.09374058
NIL
(timit)
success in 2005. trials
Cpu Time = 8.721
Elapsed Time = 24.4333334
Wholine Time = 13.0333333
GC time = 4.0E-3
Load Average Before = 2.09464288
Load Average After = 2.06371927
NIL
(timit)
success in 2005. trials
Cpu Time = 8.729
Elapsed Time = 19.65
Wholine Time = 13.55
GC time = 3.0E-3
Load Average Before = 2.05781925
Load Average After = 1.97420347
NIL
↑C
↑C
.;FFT
.r plisp
T
(fasload fft)
42650.
(timit)
Cpu Time = 4.429
Elapsed Time = 11.05
Wholine Time = 9.6
GC time = 1.48
Load Average Before = 1.75335431
Load Average After = 1.70337331
NIL
(timit)
Cpu Time = 4.416
Elapsed Time = 10.1666666
Wholine Time = 9.4166666
GC time = 1.468
Load Average Before = 1.67398107
Load Average After = 1.6314497
NIL
(timit)
Cpu Time = 4.434
Elapsed Time = 12.6833333
Wholine Time = 10.0166667
GC time = 1.477
Load Average Before = 1.60476577
Load Average After = 1.56963801
NIL
↑C
↑C
.
Exit
↑C
.COMMENT ⊗ VALID 00007 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL FFT done 10 times
C00006 00003 Barrow's FFT times
C00008 00004 InterLisp-10
C00016 00005 ∂12-May-82 0003 Mabry Tyson <Tyson at SRI-AI> UCI-Lisp timing on Barrow FFT
C00018 00006 Various machines via Barrow
C00020 00007 LM-2
C00021 ENDMK
C⊗;
;;; SAIL FFT done 10 times
.r plisp
T
(fasload fft)
42650.
(timit)
Cpu Time = 4.392
Elapsed Time = 8.15
Wholine Time = 8.1333333
GC time = 1.463
Load Average Before = 0.32191658
Load Average After = 0.361239552
NIL
(timit)
Cpu Time = 4.391
Elapsed Time = 8.1333333
Wholine Time = 8.1333333
GC time = 1.458
Load Average Before = 0.356279135
Load Average After = 0.39353633
NIL
;;; Model B from Here on down
↑C
↑C
;;; FFT (Model B)
Cpu Time = 4.004
Elapsed Time = 23.9
Wholine Time = 9.8666667
GC time = 1.833
Load Average Before = 1.12649739
Load Average After = 1.4469099
(fasload fft)
(fasload ttime fas dsk (mac lsp))
(timit)
Cpu Time = 4.0
Elapsed Time = 10.4166666
Wholine Time = 9.3833333
GC time = 2.914
Load Average Before = 0.296131015
Load Average After = 0.35368061
NIL
Cpu Time = 4.001
Elapsed Time = 10.3833333
Wholine Time = 9.4666667
GC time = 2.902
Load Average Before = 0.337160707
Load Average After = 0.392315626
NIL
Cpu Time = 4.0
Elapsed Time = 11.4833333
Wholine Time = 9.65
GC time = 2.906
Load Average Before = 0.380419016
Load Average After = 0.451439977
NIL
;;; SAIL (Model B) No Cache
(fasload fft)
(timit)
Cpu Time = 4.032
Elapsed Time = 1655.4
Wholine Time = 114.066667
GC time = 7.601
Load Average Before = 13.4277709
Load Average After = 7.070505
NIL
;;; SAIL (Model B) 1/2 cache (?)
(fasload fft)
(timit)
Cpu Time = 4.001
Elapsed Time = 17.95
Wholine Time = 16.3666666
GC time = 7.621
Load Average Before = 0.214488983
Load Average After = 0.327040195
NIL
Cpu Time = 3.996
Elapsed Time = 25.1833334
Wholine Time = 16.7166667
GC time = 7.63
Load Average Before = 0.286596775
Load Average After = 0.51067257
NIL
(timit)
Cpu Time = 4.004
Elapsed Time = 87.983334
Wholine Time = 22.2166667
GC time = 7.637
Load Average Before = 3.0016383
Load Average After = 3.9317503
NIL
(alloc '(flonum (10000. 10000. 0.15)))
(gc)
(timit)
Cpu Time = 4.006
Elapsed Time = 62.15
Wholine Time = 12.3
GC time = 2.375
Load Average Before = 4.1889869
Load Average After = 4.731683
NIL
(alloc '(flonum (100000. 100000. 0.15)))
(gc)
(timit)
Cpu Time = 4.005
Elapsed Time = 49.75
Wholine Time = 11.8166667
GC time = 2.376
Load Average Before = 4.5790273
Load Average After = 4.72924495
NIL
;;; Barrow's FFT times
---------------------------------------------------------------
| Machine & | Interpreted | Compiled | Interpreted |
| Language | Secs Ratio | Secs Ratio | /Compiled |
---------------------------------------------------------------
| | | | |
| 2060 | 28.7 1.0 | 0.532 1.0 | 53.9 |
| Maclisp | | | |
| | | | |
| LispM | 97.2 3.39 | 3.52 6.62 | 27.6 |
| Zetalisp | | | |
| | | | |
| Vax | 135.5 4.72 | 66.5 125.0 | 2.04 |
| Franzlisp | | | |
| | | | |
| 2060 | 37.3 1.30 | 12.6 23.68 | 2.96 |
| Interlisp | | | |
| | | | |
| Dolphin | 431.7 15.0 | 149.1 280.3 | 1.54 |
| Interlisp | | | |
| | | | |
---------------------------------------------------------------
-------
;;; InterLisp-10
∂07-May-82 1956 MASINTER at PARC-MAXC Interlisp-10 FFT timings
Date: 7 MAY 1982 1956-PDT
From: MASINTER at PARC-MAXC
Subject: Interlisp-10 FFT timings
To: RPG at SU-AI
cc: masinter
Here are the Interlisp-10 times I got using a slight modification
of Barrow's original translation:
Speed: 1.715 CPU seconds Space: 1 large integers
13.033 real seconds 13318 floating numbers
9.975 gc time 39 page faults
load av= .679
With MINFS(20000 FLOATP)
Speed: 1.691 CPU seconds Space: 1 large integers
4.190 real seconds 13318 floating numbers
1.917 gc time 28 page faults
load av= .724
Here is the code. First, a "fast floating" package:
(FILECREATED " 7-May-82 19:50:45" <MASINTER>FELT..3 660
previous date: "30-Mar-82 00:30:40" <MASINTER>FELT..2)
(PRETTYCOMPRINT FELTCOMS)
(RPAQQ FELTCOMS [(MACROS * FELTMACROS)
(P (MOVD (QUOTE ELT)
(QUOTE FLELT))
(MOVD (QUOTE SETA)
(QUOTE FLSETA])
(RPAQQ FELTMACROS (FLELT FLSETA))
(DECLARE: EVAL@COMPILE
(PUTPROPS FLELT MACRO [(A N)
(.FLOC. (VAG (OPENR (VAG (IPLUS (LOC A)
(ADD1 N])
(PUTPROPS FLSETA MACRO ((A N V)
(CLOSER (IPLUS (LOC A)
(ADD1 N))
(FLOAT V))))
)
(MOVD (QUOTE ELT)
(QUOTE FLELT))
(MOVD (QUOTE SETA)
(QUOTE FLSETA))
(DECLARE: DONTCOPY
(FILEMAP (NIL)))
STOP
And then FFTI
(FILECREATED " 7-May-82 19:50:31" <MASINTER>FFTI.LSP.5 3390
previous date: " 7-May-82 19:45:09" <MASINTER>FFTI.LSP.4)
(PRETTYCOMPRINT FFTICOMS)
(RPAQQ FFTICOMS ((FNS * FFTIFNS)
(LOCALVARS . T)))
(RPAQQ FFTIFNS (FFT TRY))
(DEFINEQ
(FFT
[LAMBDA (AREAL AIMAG) (* edited:
"30-Mar-82 00:25")
(* Fast Fourier
Transform AREAL = real
part, AIMAG = imaginary
part)
(PROG (AR AI PI I J K M N LE LE1 IP NV2 NM1 UR UI WR WI TR TI)
(SETQ AR AREAL) (* Initialize)
(SETQ AI AIMAG)
(SETQ PI 3.141593)
(SETQ N (ARRAYSIZE AR))
(SETQ NV2 (IQUOTIENT N 2))
(SETQ NM1 (SUB1 N))
(SETQ M 0) (* Compute M = log
(N))
(SETQ I 1)
L1 (COND
((ILESSP I N)
(SETQ M (ADD1 M))
(SETQ I (IPLUS I I))
(GO L1)))
[COND
((NOT (IEQP N (EXPT 2 M)))
(PRIN1 "Error ... array size not a power of two.")
(HELP)
(RETURN (TERPRI]
(SETQ J 1) (* Interchange elements)
(SETQ I 1) (* in bit-reversed
order)
L3 (COND
((ILESSP I J)
(SETQ TR (FLELT AR J))
(SETQ TI (FLELT AI J))
(FLSETA AR J (FLELT AR I))
(FLSETA AI J (FLELT AI I))
(FLSETA AR I TR)
(FLSETA AI I TI)))
(SETQ K NV2)
L6 (COND
((ILESSP K J)
(SETQ J (IDIFFERENCE J K))
(SETQ K (IQUOTIENT K 2))
(GO L6)))
(SETQ J (IPLUS J K))
(SETQ I (ADD1 I))
(COND
((ILESSP I N)
(GO L3)))
(for L from 1 to M
do (* Loop thru stages)
(SETQ LE (EXPT 2 L))
(SETQ LE1 (IQUOTIENT LE 2))
(SETQ UR 1.0)
(SETQ UI 0.0)
[SETQ WR (COS (FQUOTIENT PI (FLOAT LE1]
[SETQ WI (SIN (FQUOTIENT PI (FLOAT LE1]
(for J from 1 to LE1
do (* Loop thru
butterflies)
(for I←J by (IPLUS I LE) while (ILEQ I N)
do (* Do a butterfly)
(SETQ IP (IPLUS I LE1))
(SETQ TR (FDIFFERENCE (FTIMES (FLELT AR IP)
UR)
(FTIMES (FLELT AI IP)
UI)))
(SETQ TI (FPLUS (FTIMES (FLELT AR IP)
UI)
(FTIMES (FLELT AI IP)
UR)))
(FLSETA AR IP (FDIFFERENCE (FLELT AR I)
TR))
(FLSETA AI IP (FDIFFERENCE (FLELT AI I)
TI))
(FLSETA AR I (FPLUS (FLELT AR I)
TR))
(FLSETA AI I (FPLUS (FLELT AI I)
TI)))
(SETQ TR (FDIFFERENCE (FTIMES UR WR)
(FTIMES UI WI)))
(SETQ TI (FPLUS (FTIMES UR WI)
(FTIMES UI WR)))
(SETQ UR TR)
(SETQ UI TI)))
(RETURN T])
(TRY
[LAMBDA (SIZE) (* edited:
"30-Mar-82 00:26")
(COND
((NULL SIZE)
(SETQ SIZE 1024)))
(SETQ RE (ARRAY SIZE (QUOTE FLOATP)))
(SETQ IM (ARRAY SIZE (QUOTE FLOATP)))
(for I from 1 to SIZE do (FLSETA RE I (FLOAT 0))
(FLSETA IM I (FLOAT 0)))
(TIME (FFT RE IM)
1])
)
(DECLARE: DOEVAL@COMPILE DONTCOPY
(LOCALVARS . T)
)
(DECLARE: DONTCOPY
(FILEMAP (NIL (248 3309 (FFT 260 . 2954) (TRY 2958 . 3306)))))
STOP
∂12-May-82 0003 Mabry Tyson <Tyson at SRI-AI> UCI-Lisp timing on Barrow FFT
Date: 11 May 1982 2354-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: UCI-Lisp timing on Barrow FFT
To: rpg at SU-AI
Here are the results for the Barrow FFT benchmark for UCI-Lisp (version
from UTexas, run on SRI-AI 2060).
Notes for this benchmark: UCI-Lisp does not have an ARRAYCALL function. I
replaced the ARRAYCALL's by calls directly to the arrays. Also, UCI-Lisp does
not have the size of an array on the property list of the array name so I
added a parameter to FFT that is the size of the array. The arithmetic
functions COS, etc are not normally included in UCI-Lisp and are loaded from a
Fortran library by means of the loader. This existed in the original UCI-Lisp
(1973) and RUCI-Lisp but I don't know offhand if it is distributed with
Meehan's version.
Time w/o GC GC Total time
Interpreted 16.130 1.829 17.959
Compiled, slow links 6.739 1.815 8.554
Compiled, fast links 3.334 1.779 5.113
-------
Various machines via Barrow
---------------------------------------------------------------
| Machine & | Interpreted | Compiled | Interpreted |
| Language | Secs Ratio | Secs Ratio | /Compiled |
---------------------------------------------------------------
| | | | |
| 2060 | 28.7 1.0 | 0.532 1.0 | 53.9 |
| Maclisp | | | |
| | | | |
| LispM | 97.2 3.39 | 3.52 6.62 | 27.6 |
| Zetalisp | | | |
| | | | |
| Vax | 135.5 4.72 | 66.5 125.0 | 2.04 |
| Franzlisp | | | |
| | | | |
| 2060 | 37.3 1.30 | 12.6 23.68 | 2.96 |
| Interlisp | | | |
| | | | |
| Dolphin | 431.7 15.0 | 149.1 280.3 | 1.54 |
| Interlisp | | | |
| | | | |
---------------------------------------------------------------
-------
;;;LM-2
;; 10. FFT
;;; Sets up the two arrays
;---
(SETQ RE (FSYMEVAL (ARRAY RE FLONUM 1025.)))
(SETQ IM (FSYMEVAL (ARRAY IM FLONUM 1025.)))
(DEFUN TEST-FFT ()
(TIMING "FFT" (LOOP REPEAT 10. DO (FFT 'RE 'IM))))
;; Compiled: 36.8 seconds.
;; Array references compile OK in this test.
COMMENT ⊗ VALID 00003 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 TAK
C00009 00003 Incorporate this onto previous page. Results here are valid, corresponding
C00012 ENDMK
C⊗;
;TAK
.r plisp
T
(fasload tak)
43256.
(timit)
Cpu Time = 0.6
Elapsed Time = 6.95
Wholine Time = 6.9
GC time = 0.0
Load Average Before = 0.0360301733
Load Average After = 0.084010482
NIL
(timit)
Cpu Time = 0.599
Elapsed Time = 6.8666667
Wholine Time = 6.78333336
GC time = 0.0
Load Average Before = 0.088538647
Load Average After = 0.133271694
NIL
(timit)
Cpu Time = 0.598
Elapsed Time = 6.21666664
Wholine Time = 6.05
GC time = 0.0
Load Average Before = 0.135999084
Load Average After = 0.174379826
NIL
↑C
↑C
.;SCCPP
.r plisp
T
(fasload sccpp)
42755.
(timit)
Cpu Time = 1.961
Elapsed Time = 166.016666
Wholine Time = 164.716667
GC time = 20.977
Load Average Before = 0.175108433
Load Average After = 0.755509734
NIL
↑C
↑C
.;FRPOLY
.r plisp
T
(fasload frpoly)
;Loading DEFMAX 9844075.
(setup)
(Z 1. 1.0 0. (Y 1. 1.0 0. (X 1. 1.0 0. 1.0)))
(bench 2)
TEST1
Cpu Time = 6.0E-3
Elapsed Time = 0.066666666
Wholine Time = 0.066666666
GC time = 0.0
Load Average Before = 0.67449832
Load Average After = 0.67465758
TEST2
Cpu Time = 5.0E-3
Elapsed Time = 0.066666666
Wholine Time = 0.066666666
GC time = 2.0E-3
Load Average Before = 0.67273259
Load Average After = 0.67289269
TEST3
Cpu Time = 5.0E-3
Elapsed Time = 0.066666666
Wholine Time = 0.05
GC time = 0.0
Load Average Before = 0.668331385
Load Average After = 0.66845298
NIL
(bench 5)
TEST1
Cpu Time = 0.049
Elapsed Time = 0.466666665
Wholine Time = 0.466666665
GC time = 3.0E-3
Load Average Before = 0.65779948
Load Average After = 0.658968925
TEST2
Cpu Time = 0.078
Elapsed Time = 1.55
Wholine Time = 1.38333334
GC time = 0.093
Load Average Before = 0.65906179
Load Average After = 0.664173245
TEST3
Cpu Time = 0.05
Elapsed Time = 1.15
Wholine Time = 1.0
GC time = 0.088
Load Average Before = 0.663992524
Load Average After = 0.66766858
NIL
(bench 10.)
TEST1
Cpu Time = 0.552
Elapsed Time = 8.9333333
Wholine Time = 8.4666667
GC time = 0.575
Load Average Before = 0.65667188
Load Average After = 0.67758012
TEST2
Cpu Time = 1.083
Elapsed Time = 26.4
Wholine Time = 26.1166666
GC time = 2.65
Load Average Before = 0.67533922
Load Average After = 0.7333523
TEST3
Cpu Time = 0.556
Elapsed Time = 9.6
Wholine Time = 9.4166666
GC time = 0.89
Load Average Before = 0.734604955
Load Average After = 0.75346136
NIL
↑C
↑C
.;TAKL
.r plisp
T
(fasload takl)
42379.
(timit)
Cpu Time = 3.483
Elapsed Time = 31.5166667
Wholine Time = 31.3
GC time = 0.0
Load Average Before = 0.67881262
Load Average After = 0.74512339
NIL
(timit)
Cpu Time = 3.483
Elapsed Time = 31.6
Wholine Time = 31.2833333
GC time = 0.0
Load Average Before = 0.734882474
Load Average After = 0.78976333
NIL
(timit)
Cpu Time = 3.483
Elapsed Time = 31.75
Wholine Time = 31.2833333
GC time = 0.0
Load Average Before = 0.77962828
Load Average After = 0.825199604
NIL
↑C
↑C
.;TAKR
.r plisp
T
(fasload takr)
46023.
(timit)
Cpu Time = 0.858
Elapsed Time = 7.8333333
Wholine Time = 7.76666665
GC time = 0.0
Load Average Before = 0.74736333
Load Average After = 0.76147795
NIL
(timit)
Cpu Time = 0.853
Elapsed Time = 7.78333336
Wholine Time = 7.73333335
GC time = 0.0
Load Average Before = 0.74961817
Load Average After = 0.7635206
NIL
(timit)
Cpu Time = 0.853
Elapsed Time = 7.8
Wholine Time = 7.76666665
GC time = 0.0
Load Average Before = 0.752225876
Load Average After = 0.76601195
NIL
↑C
↑C
.;PUZZLE
.r plisp
T
(fasload puzzle)
42775.
(timit)
success in 2005. trials
Cpu Time = 8.709
Elapsed Time = 70.916667
Wholine Time = 69.866667
GC time = 3.0E-3
Load Average Before = 0.689958215
Load Average After = 0.81522632
NIL
(timit)
success in 2005. trials
Cpu Time = 8.707
Elapsed Time = 70.583333
Wholine Time = 70.0
GC time = 3.0E-3
Load Average Before = 0.80046928
Load Average After = 0.88121498
NIL
↑C
↑C
.;FFT
.r plisp
T
(fasload fft)
42650.
(timit)
Cpu Time = 4.42
Elapsed Time = 45.3
Wholine Time = 44.9166665
GC time = 1.474
Load Average Before = 0.794517994
Load Average After = 0.85267866
NIL
(timit)
Cpu Time = 4.423
Elapsed Time = 45.3166666
Wholine Time = 44.85
GC time = 1.465
Load Average Before = 0.84016311
Load Average After = 0.885448575
NIL
↑C
↑C
.;ENDK/F
.
; Incorporate this onto previous page. Results here are valid, corresponding
; ones on previous are not.
;TAK
.r plisp
T
(fasload tak)
43469.
(timit)
Cpu Time = 0.6
Elapsed Time = 9.2166667
Wholine Time = 5.8333333
GC Time = 0.0
Load Average Before = 0.0291053057
Load Average After = 0.077205062
Average Load Average =0.053155184
NIL
(timit)
Cpu Time = 0.599
Elapsed Time = 6.95
Wholine Time = 5.51666665
GC Time = 0.0
Load Average Before = 0.083017826
Load Average After = 0.128553629
Average Load Average =0.1057857275
NIL
(timit)
Cpu Time = 0.598
Elapsed Time = 6.06666666
Wholine Time = 6.01666665
GC Time = 0.0
Load Average Before = 0.133602858
Load Average After = 0.171280622
Average Load Average =0.15244174
NIL
↑C
↑C
.;TAKR
.r plisp
T
(fasload takr)
46138.
(timit)
Cpu Time = 0.604
Elapsed Time = 6.15
Wholine Time = 6.06666666
GC Time = 0.0
Load Average Before = 0.179979563
Load Average After = 0.216120481
Average Load Average =0.198050022
NIL
(timit)
Cpu Time = 0.599
Elapsed Time = 6.1
Wholine Time = 6.01666665
GC Time = 0.0
Load Average Before = 0.218356013
Load Average After = 0.25253284
Average Load Average =0.235444427
NIL
(timit)
Cpu Time = 0.599
Elapsed Time = 6.3333333
Wholine Time = 6.3
GC Time = 0.0
Load Average Before = 0.253887177
Load Average After = 0.287730336
Average Load Average =0.270808756
NIL
↑C
↑C
.;END
.K/F
Kjob
.
COMMENT ⊗ VALID 00004 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 00003 ∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
C00009 00004 LM-2
C00010 ENDMK
C⊗;
; SAIL
(fasload fdderiv)
(timit)
Timing performed on Friday 07/16/82 at 10:14:31.
Cpu Time = 2.533
Elapsed Time = 188.9
Wholine Time = 53.2
GC Time = 21.323
Load Average Before = 0.651587844
Load Average After = 2.27102423
Average Load Average = 1.46130604
NIL
Timing performed on Friday 07/16/82 at 10:17:51.
Cpu Time = 2.531
Elapsed Time = 95.516666
Wholine Time = 47.3333335
GC Time = 19.569
Load Average Before = 2.1588266
Load Average After = 2.29448807
Average Load Average = 2.22665733
NIL
Timing performed on Friday 07/16/82 at 10:20:18.
Cpu Time = 2.5
Elapsed Time = 239.716667
Wholine Time = 41.5
GC Time = 19.381
Load Average Before = 2.20678627
Load Average After = 3.79014647
Average Load Average = 2.99846637
NIL
∂16-Jul-82 0012 Mabry Tyson <Tyson at SRI-AI> DERIV, DDERIV, FDDERIV results
Date: 16 Jul 1982 0003-PDT
From: Mabry Tyson <Tyson at SRI-AI>
Subject: DERIV, DDERIV, FDDERIV results
To: rpg at SU-AI
Results for DERIV, DDERIV, FDDERIV for UCILISP (UT's version).
All timings are on SRI-AI's 2060 with load average around 0.2.
Notes on coding of the programs:
UCILISP open codes MAPCAR if the function is specified by a
LAMBDA expression but does not if the function is a defined function.
Therefore, (MAPCAR 'FOO BAR) was translated into (MAPCAR (FUNCTION
(LAMBDA (X) (FOO X))) BAR) to keep in the spirit of the open coded
version sent out.
DDERIV and FDDERIV involve calling a function which is the value of
a local variable. In UCILISP this may be done by simply calling
(FOO ...) where FOO is the local variable rather than fooling with
FUNCALL or SUBRCALL. This format handles both cases. With (NOUUO
NIL), these function calls do not become direct jumps (because the
value may change next time).
There was a slight problem in having the compiler produce SUBR code
to be stored under a different property (DERIV). It could be done
but not conveniently. So I just compiled the code as SUBR's and
editted the LAP code to make it load onto the DERIV property.
DDERIV and FDDERIV were the version that had the (CONS 'TIMES A) in
the definition for TIMES.
The loop was a PROG which had 5 calls to DERIV and looped 1000 times.
The function that did this was compiled to minimize the overhead.
In order to compute the overhead, I had a similar loop that called
a dummy function that just returned its arguments. Its cost was
about 0.21 seconds for the (NOUUO T) case and about 0.04 seconds
for the (NOUUO NIL) case. I did NOT subtract these out in the following
results (but I feel they should be).
Each test run produced about 265000 conses and I had about 150000 free words.
I did a GC before each run to keep things as constant as possible.
Function (NOUUO T) (NOUUO NIL)
DERIV 14.879-0.875 (.213) 4.451-0.868 (.043)
DDERIV 16.250-0.856 (.198) 4.983-0.855 (.044)
FDDERIV 16.073-0.873 (.211) 4.857-0.871 (.028)
DDERIV* 18.171-1.742 (.212) 6.091-1.717 (.043)
The format of the times are
total-gc (dummy)
where total is the total CPU time (including GC), GC is the amount used for
garbage collection and dummy is the amount of time used by the dummy loop. I
believe the clock ticks about every 0.015 seconds which explains the
difference between the .028 and .044 dummy times (one less tick).
Explanation of results:
I believe the second and third to be slower because the property list of
the variable (whose value was the property name) had to be searched twice,
first for a function property and then for the value of the variable.
Then, for the DDERIV case, another property list had to be searched to
find the function definition.
The DDERIV* case is one in which a FUNCALL is used. In UCILISP this
results in an extra CONS and a call to APPLY* which then does everything
done above. As you can see, it is slower.
-------
;;;LM-2
;; 9. FDERIV
;; FDDERIV 3 shouldn't be any different on the LM-2 than DDERIV, if I understand
;; it correctly.
;; 8. DDERIV
(DEFUN TEST-DDERIV ()
(TIMING "DDERIV" (RUN)))
;; Compiled: 25.4 seconds.
al tim,lsp
.;TAK
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload tak)
122156
124543
(timit)
Cpu Time = 3.15
Elapsed Time = 4.15
Wholine Time = 3.13333333
GC Time = 0.0
Load Average Before = 0.77695
Load Average After = 0.794682145
Average Load Average =0.78581607
NIL
(timit)
Cpu Time = 3.15
Elapsed Time = 3.38333333
Wholine Time = 3.15
GC Time = 0.0
Load Average Before = 0.79195881
Load Average After = 0.7969141
Average Load Average =0.794436455
NIL
(timit)
Cpu Time = 3.067
Elapsed Time = 3.75
Wholine Time = 3.06666666
GC Time = 0.0
Load Average Before = 0.78891969
Load Average After = 0.79432464
Average Load Average =0.79162216
NIL
↑C
↑C
.;SCCPP
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload sccpp)
122156
123231
(timit)
Cpu Time = 10.817
Elapsed Time = 179.583334
Wholine Time = 99.133333
GC time = 88.317
Load Average Before = 0.744469285
Load Average After = 1.3840766
NIL
↑C
↑C
.;FRPOLY
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload frpoly)
122156
;Loading DEFMAX 9843969.
(setup)
(Z 1. 1.0 0. (Y 1. 1.0 0. (X 1. 1.0 0. 1.0)))
(bench 2)
TEST1
Cpu Time = 0.034
Elapsed Time = 0.033333333
Wholine Time = 0.033333333
GC time = 0.0
Load Average Before = 1.39931667
Load Average After = 1.40019584
TEST2
Cpu Time = 0.033
Elapsed Time = 0.033333333
Wholine Time = 0.0166666666
GC time = 0.0
Load Average Before = 1.44752073
Load Average After = 1.4475882
TEST3
Cpu Time = 0.033
Elapsed Time = 0.033333333
Wholine Time = 0.033333333
GC time = 0.0
Load Average Before = 1.52500689
Load Average After = 1.52506495
NIL
(bench 5)
TEST1
Cpu Time = 0.25
Elapsed Time = 0.266666666
Wholine Time = 0.25
GC time = 0.017
Load Average Before = 1.52420199
Load Average After = 1.52507329
TEST2
Cpu Time = 0.383
Elapsed Time = 0.4
Wholine Time = 0.416666668
GC time = 0.017
Load Average Before = 1.52902389
Load Average After = 1.5304606
TEST3
Cpu Time = 0.316
Elapsed Time = 0.416666668
Wholine Time = 0.316666666
GC time = 0.0
Load Average Before = 1.53971934
Load Average After = 1.54112363
NIL
(bench 10.)
TEST1
Cpu Time = 2.898
Elapsed Time = 3.61666667
Wholine Time = 2.98333332
GC time = 0.085
Load Average Before = 1.53941345
Load Average After = 1.55172026
TEST2
Cpu Time = 5.9
Elapsed Time = 47.8166666
Wholine Time = 12.9166666
GC time = 7.017
Load Average Before = 1.554335
Load Average After = 1.83701074
TEST3
Cpu Time = 3.167
Elapsed Time = 21.8166666
Wholine Time = 8.7
GC time = 5.533
Load Average Before = 1.83780217
Load Average After = 1.87494707
NIL
(bench 15.)
TEST1
Cpu Time = 19.817
Elapsed Time = 66.866667
Wholine Time = 25.6833334
GC time = 5.85
Load Average Before = 1.86221766
Load Average After = 2.0245961
TEST2
Cpu Time = 60.504
Elapsed Time = 499.166668
Wholine Time = 249.133333
GC time = 188.646
Load Average Before = 2.0179292
Load Average After = 1.79667938
TEST3
Cpu Time = 21.033
Elapsed Time = 294.916668
Wholine Time = 118.116667
GC time = 97.083
Load Average Before = 1.80685198
Load Average After = 1.95107663
NIL
↑C
↑C
.;TAKL
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload takl)
122156
122441
(timit)
Cpu Time = 19.5
Elapsed Time = 98.7
Wholine Time = 19.4833333
GC time = 0.0
Load Average Before = 1.87827063
Load Average After = 2.1224885
NIL
(timit)
Cpu Time = 17.75
Elapsed Time = 38.4666667
Wholine Time = 17.7666667
GC time = 0.0
Load Average Before = 2.08083928
Load Average After = 1.98668945
NIL
(timit)
Cpu Time = 17.7
Elapsed Time = 29.6666667
Wholine Time = 17.7166667
GC time = 0.0
Load Average Before = 1.95545018
Load Average After = 1.85742676
NIL
↑C
↑C
;TAKR
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload takr)
122156
131720
(timit)
Cpu Time = 3.133
Elapsed Time = 3.41666666
Wholine Time = 3.13333333
GC Time = 0.0
Load Average Before = 1.18144155
Load Average After = 1.20141101
Average Load Average =1.19142628
NIL
(timit)
Cpu Time = 3.016
Elapsed Time = 3.4
Wholine Time = 3.01666668
GC Time = 0.0
Load Average Before = 1.20924914
Load Average After = 1.22866106
Average Load Average =1.2189551
NIL
(timit)
Cpu Time = 3.016
Elapsed Time = 3.68333334
Wholine Time = 3.01666668
GC Time = 0.0
Load Average Before = 1.23773646
Load Average After = 1.256832
Average Load Average =1.24728423
NIL
↑C
.;PUZZLE
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload puzzle)
122156
123255
(timit)
success in 3725 trials
Cpu Time = 54.45
Elapsed Time = 189.916666
Wholine Time = 54.4666667
GC time = 0.0
Load Average Before = 1.61420548
Load Average After = 2.1967162
NIL
(timit)
success in 3725 trials
Cpu Time = 53.0
Elapsed Time = 172.9
Wholine Time = 53.0
GC time = 0.0
Load Average Before = 2.17755556
Load Average After = 2.2638005
NIL
(timit)
success in 3725 trials
Cpu Time = 52.283
Elapsed Time = 114.633333
Wholine Time = 52.2833333
GC time = 0.017
Load Average Before = 2.2425928
Load Average After = 2.12427628
NIL
↑C
↑C
.;FFT
.r plisp
122131
(fasload ttime fas dsk (mac lsp))(fasload fft)
122156
123060
(timit)
Cpu Time = 30.333
Elapsed Time = 71.816667
Wholine Time = 35.5833335
GC time = 5.234
Load Average Before = 1.99925458
Load Average After = 1.99921274
NIL
(timit)
Cpu Time = 30.383
Elapsed Time = 76.966666
Wholine Time = 35.7833333
GC time = 5.384
Load Average Before = 1.9850266
Load Average After = 1.99325657
NIL
(timit)
Cpu Time = 30.581
Elapsed Time = 81.283334
Wholine Time = 36.0666666
GC time = 5.486
Load Average Before = 1.97926891
Load Average After = 2.0119208
NIL
↑C
↑C
.;END
.K/F
Kjob
.
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 AAM Puzzle
C00003 ENDMK
C⊗;
; AAM Puzzle
(fasload aam)
(timit)
Timing performed on Saturday 05/29/82 at 03:16:47.
Cpu Time = 98.101
Elapsed Time = 153.4
Wholine Time = 138.183332
GC Time = 6.803
Load Average Before = 0.220208287
Load Average After = 0.802041054
Average Load Average = 0.51112467
NIL
Timing performed on Saturday 05/29/82 at 03:20:11.
Cpu Time = 98.095
Elapsed Time = 145.666666
Wholine Time = 130.733334
GC Time = 1.053
Load Average Before = 0.56515789
Load Average After = 0.893422365
Average Load Average = 0.72929013
NIL
COMMENT ⊗ VALID 00004 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL 100. 10. 4.
C00004 00003 SAIL 100. 10. 4.
C00006 00004 SAIL 100. 10. 4. (model B)
C00007 ENDMK
C⊗;
;;; SAIL 100. 10. 4.
(fasload browse)
(timit)
Timing performed on Thursday 09/09/82 at 14:32:20.
Cpu Time = 13.635
Elapsed Time = 133.4
Wholine Time = 95.183333
GC Time = 40.438
Load Average Before = 1.96977687
Load Average After = 1.68995798
Average Load Average = 1.82986742
NIL
Timing performed on Thursday 09/09/82 at 14:35:00.
Cpu Time = 13.635
Elapsed Time = 228.583334
Wholine Time = 93.166667
GC Time = 39.524
Load Average Before = 1.89986777
Load Average After = 2.54795516
Average Load Average = 2.22391146
NIL
Timing performed on Thursday 09/09/82 at 14:38:59.
Cpu Time = 13.652
Elapsed Time = 174.683332
Wholine Time = 93.5
GC Time = 39.934
Load Average Before = 2.3873887
Load Average After = 2.08130932
Average Load Average = 2.234349
NIL
;;; SAIL 100. 10. 4.
(fasload browse)
(timit)(timit)(timit)
Timing performed on Sunday 02/13/83 at 14:27:32.
Cpu (- GC) Time = 13.896
Elapsed Time = 218.533333
Wholine Time = 100.266666
GC Time = 39.704
Load Average Before = 2.77352154
Load Average After = 2.62624335
Average Load Average = 2.69988245
NIL
Timing performed on Sunday 02/13/83 at 14:31:15.
Cpu (- GC) Time = 13.777
Elapsed Time = 216.216667
Wholine Time = 97.55
GC Time = 38.776
Load Average Before = 2.55250084
Load Average After = 2.45873046
Average Load Average = 2.50561565
NIL
Timing performed on Sunday 02/13/83 at 14:34:52.
Cpu (- GC) Time = 13.865
Elapsed Time = 258.616665
Wholine Time = 97.566667
GC Time = 38.935
Load Average Before = 2.4577961
Load Average After = 2.8594705
Average Load Average = 2.6586333
NIL
;;; SAIL 100. 10. 4. (model B)
(fasload browse)
(timit)
Timing performed on Sunday 02/27/83 at 20:20:13.
Cpu (- GC) Time = 12.043
Elapsed Time = 274.05
Wholine Time = 82.683333
GC Time = 35.696
Load Average Before = 0.76563597
Load Average After = 3.6514511
Average Load Average = 2.20854354
NIL
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00005 ENDMK
C⊗;
;;; SAIL
(fasload div2)
(timit1)
(timit2)
Timing performed on Thursday 09/09/82 at 15:18:56.
Cpu Time = 0.987
Elapsed Time = 38.2
Wholine Time = 16.4833333
GC Time = 9.291
Load Average Before = 2.66155326
Load Average After = 3.47313
Average Load Average = 3.06734163
NIL
Timing performed on Thursday 09/09/82 at 15:19:41.
Cpu Time = 1.46
Elapsed Time = 52.8
Wholine Time = 17.2833333
GC Time = 9.342
Load Average Before = 3.48316622
Load Average After = 4.245383
Average Load Average = 3.86427462
NIL
Timing performed on Thursday 09/09/82 at 15:22:03.
Cpu Time = 0.985
Elapsed Time = 17.9166667
Wholine Time = 16.1833334
GC Time = 8.875
Load Average Before = 2.967914
Load Average After = 3.41819358
Average Load Average = 3.19305378
NIL
Timing performed on Thursday 09/09/82 at 15:22:22.
Cpu Time = 1.462
Elapsed Time = 49.35
Wholine Time = 19.1833334
GC Time = 9.371
Load Average Before = 3.41771114
Load Average After = 3.10541797
Average Load Average = 3.26156455
NIL
Timing performed on Thursday 09/09/82 at 15:23:13.
Cpu Time = 0.986
Elapsed Time = 37.1833334
Wholine Time = 17.3166666
GC Time = 9.331
Load Average Before = 3.087242
Load Average After = 2.8620081
Average Load Average = 2.97462505
NIL
Timing performed on Thursday 09/09/82 at 15:23:55.
Cpu Time = 1.455
Elapsed Time = 35.3166666
Wholine Time = 17.45
GC Time = 8.921
Load Average Before = 2.84874082
Load Average After = 2.6801182
Average Load Average = 2.7644295
NIL
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00019 ENDMK
C⊗;
;;; SAIL
(fasload tprint)
(timit)
Into file (LPEND)
Timing performed on Sunday 09/12/82 at 15:25:22.
Cpu Time = 1.268
Elapsed Time = 245.45
Wholine Time = 6.1
GC Time = 0.0
Load Average Before = 1.58466601
Load Average After = 1.39642692
Average Load Average = 1.49054646
NIL
Onto screen (PPSAVE)
Timing performed on Sunday 09/12/82 at 15:30:22.
Cpu Time = 0.81
Elapsed Time = 96.466666
Wholine Time = 6.51666665
GC Time = 0.0
Load Average Before = 1.2683934
Load Average After = 1.53600466
Average Load Average = 1.40219903
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 ENDMK
C⊗;
;;; SAIL
(fasload fread)
(timit)
Timing performed on Monday 09/13/82 at 12:00:41.
Cpu Time = 1.127
Elapsed Time = 2.73333332
Wholine Time = 2.0
GC Time = 0.0
Load Average Before = 1.79554164
Load Average After = 1.82315683
Average Load Average = 1.80934924
NIL
Timing performed on Monday 09/13/82 at 12:00:46.
Cpu Time = 1.122
Elapsed Time = 3.26666668
Wholine Time = 2.66666666
GC Time = 0.458
Load Average Before = 1.82150424
Load Average After = 1.82264411
Average Load Average = 1.82207417
NIL
Timing performed on Monday 09/13/82 at 12:00:52.
Cpu Time = 1.114
Elapsed Time = 2.55
Wholine Time = 1.78333333
GC Time = 0.0
Load Average Before = 1.8146143
Load Average After = 1.81938088
Average Load Average = 1.81699759
NIL
Timing performed on Monday 09/13/82 at 12:00:56.
Cpu Time = 1.119
Elapsed Time = 3.53333333
Wholine Time = 2.71666667
GC Time = 0.447
Load Average Before = 1.80403054
Load Average After = 1.7872715
Average Load Average = 1.79565102
NIL
Timing performed on Monday 09/13/82 at 12:01:02.
Cpu Time = 1.112
Elapsed Time = 2.43333334
Wholine Time = 1.9
GC Time = 0.0
Load Average Before = 1.7785083
Load Average After = 1.76736653
Average Load Average = 1.77293742
NIL
COMMENT ⊗ VALID 00013 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 Comparison of LISPS
C00004 00003 The ELISP code
C00025 00004 (FILECREATED " 5-Jul-82 12:52:49" <CL.BOYER.LISPS>IREWRITE..4 14918
C00050 00005 The Maclisp Code
C00071 00006 The ELISP test
C00072 00007 Interlisp bcompl blocklib swap and noswap
C00075 00008 Interlisp bcompl no blocklib swap and noswap
C00079 00009 Maclisp
C00085 00010 Interlisp (Dolphin and Dorado)
C00116 00011 The INTERLISP VAX test
C00119 00012 SAIL
C00121 00013 SAIL (FIXSW T)
C00123 ENDMK
C⊗;
Comparison of LISPS
This page contains a summary. Subsequent pages contain the
code used and documentation of the tests. All the code was compiled.
Non GC time (seconds) GC time Total
MACLISP (2060) 8.5 5.3 13.8
UCILISP (2060, (nouuo nil)) 9.3 4.7 14
INTERLISP (bcompl, blklib, swap, 2060) 11 6 17
ELISP (2060) 11 7 18
INTERLISP (bcompl, blklib, noswap, 2060) 11 7.5 18.5
INTERLISP (Dorado, bcompl, blklib) 18 11 29
INTERLISP (bcompl, no blklib, noswap, 2060) 39 7 46
INTERLISP (bcompl, no blklib, swap, 2060) 64 6 70
INTERLISP (VAX-780) 80 3 83
ZETALISP (LM-2, 1meg, gc-on) breakdown not available 97
INTERLISP (Dolphin, 1meg, bcompl, blklib) 132 35 167
The ELISP code
(DECLARE (SPECIAL UNIFY-SUBST TEMP-TEMP))
(DE ADD-LEMMA (TERM)
(COND ((AND (NOT (ATOM TERM))
(EQ (CAR TERM)
(QUOTE EQUAL))
(NOT (ATOM (CADR TERM))))
(PUTPROP (CAR (CADR TERM))
(CONS TERM (GET (CAR (CADR TERM))
(QUOTE LEMMAS)))
(QUOTE LEMMAS)))
(T (ERROR (LIST (QUOTE ADD-LEMMA-DID-NOT-LIKE-TERM) TERM)
))))
(DE ADD-LEMMA-LST (LST)
(COND ((NULL LST)
T)
(T (ADD-LEMMA (CAR LST))
(ADD-LEMMA-LST (CDR LST)))))
(DE APPLY-SUBST (ALIST TERM)
(COND ((ATOM TERM)
(COND ((SETQ TEMP-TEMP (ASSOC TERM ALIST))
(CDR TEMP-TEMP))
(T TERM)))
(T (CONS (CAR TERM)
(APPLY-SUBST-LST ALIST (CDR TERM))))))
(DE APPLY-SUBST-LST (ALIST LST)
(COND ((NULL LST)
NIL)
(T (CONS (APPLY-SUBST ALIST (CAR LST))
(APPLY-SUBST-LST ALIST (CDR LST))))))
(DE FALSEP (X LST)
(OR (EQUAL X (QUOTE (F)))
(MEMBER X LST)))
(DE ONE-WAY-UNIFY (TERM1 TERM2)
(PROGN (SETQ UNIFY-SUBST NIL)
(ONE-WAY-UNIFY1 TERM1 TERM2)))
(DE ONE-WAY-UNIFY1 (TERM1 TERM2)
(COND ((ATOM TERM2)
(COND ((SETQ TEMP-TEMP (ASSOC TERM2 UNIFY-SUBST))
(EQUAL TERM1 (CDR TEMP-TEMP)))
(T (SETQ UNIFY-SUBST (CONS (CONS TERM2 TERM1)
UNIFY-SUBST))
T)))
((ATOM TERM1)
NIL)
((EQ (CAR TERM1)
(CAR TERM2))
(ONE-WAY-UNIFY1-LST (CDR TERM1)
(CDR TERM2)))
(T NIL)))
(DE ONE-WAY-UNIFY1-LST (LST1 LST2)
(COND ((NULL LST1)
T)
((ONE-WAY-UNIFY1 (CAR LST1)
(CAR LST2))
(ONE-WAY-UNIFY1-LST (CDR LST1)
(CDR LST2)))
(T NIL)))
(DE REWRITE (TERM)
(COND ((ATOM TERM)
TERM)
(T (REWRITE-WITH-LEMMAS (CONS (CAR TERM)
(REWRITE-ARGS (CDR TERM)))
(GET (CAR TERM)
(QUOTE LEMMAS))))))
(DE REWRITE-ARGS (LST)
(COND ((NULL LST)
NIL)
(T (CONS (REWRITE (CAR LST))
(REWRITE-ARGS (CDR LST))))))
(DE REWRITE-WITH-LEMMAS (TERM LST)
(COND ((NULL LST)
TERM)
((ONE-WAY-UNIFY TERM (CADR (CAR LST)))
(REWRITE (APPLY-SUBST UNIFY-SUBST (CADDR (CAR LST)))))
(T (REWRITE-WITH-LEMMAS TERM (CDR LST)))))
(DE
SETUP NIL
(ADD-LEMMA-LST
(QUOTE ((EQUAL (COMPILE FORM)
(REVERSE (CODEGEN (OPTIMIZE FORM)
(NIL))))
(EQUAL (EQP X Y)
(EQUAL (FIX X)
(FIX Y)))
(EQUAL (GREATERP X Y)
(LESSP Y X))
(EQUAL (LESSEQP X Y)
(NOT (LESSP Y X)))
(EQUAL (GREATEREQP X Y)
(NOT (LESSP X Y)))
(EQUAL (BOOLEAN X)
(OR (EQUAL X (T))
(EQUAL X (F))))
(EQUAL (IFF X Y)
(AND (IMPLIES X Y)
(IMPLIES Y X)))
(EQUAL (EVEN1 X)
(IF (ZEROP X)
(T)
(ODD (SUB1 X))))
(EQUAL (COUNTPS- L PRED)
(COUNTPS-LOOP L PRED (ZERO)))
(EQUAL (FACT- I)
(FACT-LOOP I 1))
(EQUAL (REVERSE- X)
(REVERSE-LOOP X (NIL)))
(EQUAL (DIVIDES X Y)
(ZEROP (REMAINDER Y X)))
(EQUAL (ASSUME-TRUE VAR ALIST)
(CONS (CONS VAR (T))
ALIST))
(EQUAL (ASSUME-FALSE VAR ALIST)
(CONS (CONS VAR (F))
ALIST))
(EQUAL (TAUTOLOGY-CHECKER X)
(TAUTOLOGYP (NORMALIZE X)
(NIL)))
(EQUAL (FALSIFY X)
(FALSIFY1 (NORMALIZE X)
(NIL)))
(EQUAL (PRIME X)
(AND (NOT (ZEROP X))
(NOT (EQUAL X (ADD1 (ZERO))))
(PRIME1 X (SUB1 X))))
(EQUAL (AND P Q)
(IF P (IF Q (T)
(F))
(F)))
(EQUAL (OR P Q)
(IF P (T)
(IF Q (T)
(F))
(F)))
(EQUAL (NOT P)
(IF P (F)
(T)))
(EQUAL (IMPLIES P Q)
(IF P (IF Q (T)
(F))
(T)))
(EQUAL (FIX X)
(IF (NUMBERP X)
X
(ZERO)))
(EQUAL (IF (IF A B C)
D E)
(IF A (IF B D E)
(IF C D E)))
(EQUAL (ZEROP X)
(OR (EQUAL X (ZERO))
(NOT (NUMBERP X))))
(EQUAL (PLUS (PLUS X Y)
Z)
(PLUS X (PLUS Y Z)))
(EQUAL (EQUAL (PLUS A B)
(ZERO))
(AND (ZEROP A)
(ZEROP B)))
(EQUAL (DIFFERENCE X X)
(ZERO))
(EQUAL (EQUAL (PLUS A B)
(PLUS A C))
(EQUAL (FIX B)
(FIX C)))
(EQUAL (EQUAL (ZERO)
(DIFFERENCE X Y))
(NOT (LESSP Y X)))
(EQUAL (EQUAL X (DIFFERENCE X Y))
(AND (NUMBERP X)
(OR (EQUAL X (ZERO))
(ZEROP Y))))
(EQUAL (MEANING (PLUS-TREE (APPEND X Y))
A)
(PLUS (MEANING (PLUS-TREE X)
A)
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (MEANING (PLUS-TREE (PLUS-FRINGE X))
A)
(FIX (MEANING X A)))
(EQUAL (APPEND (APPEND X Y)
Z)
(APPEND X (APPEND Y Z)))
(EQUAL (REVERSE (APPEND A B))
(APPEND (REVERSE B)
(REVERSE A)))
(EQUAL (TIMES X (PLUS Y Z))
(PLUS (TIMES X Y)
(TIMES X Z)))
(EQUAL (TIMES (TIMES X Y)
Z)
(TIMES X (TIMES Y Z)))
(EQUAL (EQUAL (TIMES X Y)
(ZERO))
(OR (ZEROP X)
(ZEROP Y)))
(EQUAL (EXEC (APPEND X Y)
PDS ENVRN)
(EXEC Y (EXEC X PDS ENVRN)
ENVRN))
(EQUAL (MC-FLATTEN X Y)
(APPEND (FLATTEN X)
Y))
(EQUAL (MEMBER X (APPEND A B))
(OR (MEMBER X A)
(MEMBER X B)))
(EQUAL (MEMBER X (REVERSE Y))
(MEMBER X Y))
(EQUAL (LENGTH (REVERSE X))
(LENGTH X))
(EQUAL (MEMBER A (INTERSECT B C))
(AND (MEMBER A B)
(MEMBER A C)))
(EQUAL (NTH (ZERO)
I)
(ZERO))
(EQUAL (EXP I (PLUS J K))
(TIMES (EXP I J)
(EXP I K)))
(EQUAL (EXP I (TIMES J K))
(EXP (EXP I J)
K))
(EQUAL (REVERSE-LOOP X Y)
(APPEND (REVERSE X)
Y))
(EQUAL (REVERSE-LOOP X (NIL))
(REVERSE X))
(EQUAL (COUNT-LIST Z (SORT-LP X Y))
(PLUS (COUNT-LIST Z X)
(COUNT-LIST Z Y)))
(EQUAL (EQUAL (APPEND A B)
(APPEND A C))
(EQUAL B C))
(EQUAL (PLUS (REMAINDER X Y)
(TIMES Y (QUOTIENT X Y)))
(FIX X))
(EQUAL (POWER-EVAL (BIG-PLUS1 L I BASE)
BASE)
(PLUS (POWER-EVAL L BASE)
I))
(EQUAL (POWER-EVAL (BIG-PLUS X Y I BASE)
BASE)
(PLUS I (PLUS (POWER-EVAL X BASE)
(POWER-EVAL Y BASE))))
(EQUAL (REMAINDER Y 1)
(ZERO))
(EQUAL (LESSP (REMAINDER X Y)
Y)
(NOT (ZEROP Y)))
(EQUAL (REMAINDER X X)
(ZERO))
(EQUAL (LESSP (QUOTIENT I J)
I)
(AND (NOT (ZEROP I))
(OR (ZEROP J)
(NOT (EQUAL J 1)))))
(EQUAL (LESSP (REMAINDER X Y)
X)
(AND (NOT (ZEROP Y))
(NOT (ZEROP X))
(NOT (LESSP X Y))))
(EQUAL (POWER-EVAL (POWER-REP I BASE)
BASE)
(FIX I))
(EQUAL (POWER-EVAL (BIG-PLUS (POWER-REP I BASE)
(POWER-REP J BASE)
(ZERO)
BASE)
BASE)
(PLUS I J))
(EQUAL (GCD X Y)
(GCD Y X))
(EQUAL (NTH (APPEND A B)
I)
(APPEND (NTH A I)
(NTH B (DIFFERENCE I (LENGTH A)))))
(EQUAL (DIFFERENCE (PLUS X Y)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS Y X)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS X Y)
(PLUS X Z))
(DIFFERENCE Y Z))
(EQUAL (TIMES X (DIFFERENCE C W))
(DIFFERENCE (TIMES C X)
(TIMES W X)))
(EQUAL (REMAINDER (TIMES X Z)
Z)
(ZERO))
(EQUAL (DIFFERENCE (PLUS B (PLUS A C))
A)
(PLUS B C))
(EQUAL (DIFFERENCE (ADD1 (PLUS Y Z))
Z)
(ADD1 Y))
(EQUAL (LESSP (PLUS X Y)
(PLUS X Z))
(LESSP Y Z))
(EQUAL (LESSP (TIMES X Z)
(TIMES Y Z))
(AND (NOT (ZEROP Z))
(LESSP X Y)))
(EQUAL (LESSP Y (PLUS X Y))
(NOT (ZEROP X)))
(EQUAL (GCD (TIMES X Z)
(TIMES Y Z))
(TIMES Z (GCD X Y)))
(EQUAL (VALUE (NORMALIZE X)
A)
(VALUE X A))
(EQUAL (EQUAL (FLATTEN X)
(CONS Y (NIL)))
(AND (NLISTP X)
(EQUAL X Y)))
(EQUAL (LISTP (GOPHER X))
(LISTP X))
(EQUAL (SAMEFRINGE X Y)
(EQUAL (FLATTEN X)
(FLATTEN Y)))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
(ZERO))
(AND (OR (ZEROP Y)
(EQUAL Y 1))
(EQUAL X (ZERO))))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
1)
(EQUAL X 1))
(EQUAL (NUMBERP (GREATEST-FACTOR X Y))
(NOT (AND (OR (ZEROP Y)
(EQUAL Y 1))
(NOT (NUMBERP X)))))
(EQUAL (TIMES-LIST (APPEND X Y))
(TIMES (TIMES-LIST X)
(TIMES-LIST Y)))
(EQUAL (PRIME-LIST (APPEND X Y))
(AND (PRIME-LIST X)
(PRIME-LIST Y)))
(EQUAL (EQUAL Z (TIMES W Z))
(AND (NUMBERP Z)
(OR (EQUAL Z (ZERO))
(EQUAL W 1))))
(EQUAL (GREATEREQPR X Y)
(NOT (LESSP X Y)))
(EQUAL (EQUAL X (TIMES X Y))
(OR (EQUAL X (ZERO))
(AND (NUMBERP X)
(EQUAL Y 1))))
(EQUAL (REMAINDER (TIMES Y X)
Y)
(ZERO))
(EQUAL (EQUAL (TIMES A B)
1)
(AND (NOT (EQUAL A (ZERO)))
(NOT (EQUAL B (ZERO)))
(NUMBERP A)
(NUMBERP B)
(EQUAL (SUB1 A)
(ZERO))
(EQUAL (SUB1 B)
(ZERO))))
(EQUAL (LESSP (LENGTH (DELETE X L))
(LENGTH L))
(MEMBER X L))
(EQUAL (SORT2 (DELETE X L))
(DELETE X (SORT2 L)))
(EQUAL (DSORT X)
(SORT2 X))
(EQUAL (LENGTH (CONS X1
(CONS X2
(CONS X3 (CONS X4
(CONS X5
(CONS X6 X7)))))))
(PLUS 6 (LENGTH X7)))
(EQUAL (DIFFERENCE (ADD1 (ADD1 X))
2)
(FIX X))
(EQUAL (QUOTIENT (PLUS X (PLUS X Y))
2)
(PLUS X (QUOTIENT Y 2)))
(EQUAL (SIGMA (ZERO)
I)
(QUOTIENT (TIMES I (ADD1 I))
2))
(EQUAL (PLUS X (ADD1 Y))
(IF (NUMBERP Y)
(ADD1 (PLUS X Y))
(ADD1 X)))
(EQUAL (EQUAL (DIFFERENCE X Y)
(DIFFERENCE Z Y))
(IF (LESSP X Y)
(NOT (LESSP Y Z))
(IF (LESSP Z Y)
(NOT (LESSP Y X))
(EQUAL (FIX X)
(FIX Z)))))
(EQUAL (MEANING (PLUS-TREE (DELETE X Y))
A)
(IF (MEMBER X Y)
(DIFFERENCE (MEANING (PLUS-TREE Y)
A)
(MEANING X A))
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (TIMES X (ADD1 Y))
(IF (NUMBERP Y)
(PLUS X (TIMES X Y))
(FIX X)))
(EQUAL (NTH (NIL)
I)
(IF (ZEROP I)
(NIL)
(ZERO)))
(EQUAL (LAST (APPEND A B))
(IF (LISTP B)
(LAST B)
(IF (LISTP A)
(CONS (CAR (LAST A))
B)
B)))
(EQUAL (EQUAL (LESSP X Y)
Z)
(IF (LESSP X Y)
(EQUAL T Z)
(EQUAL F Z)))
(EQUAL (ASSIGNMENT X (APPEND A B))
(IF (ASSIGNEDP X A)
(ASSIGNMENT X A)
(ASSIGNMENT X B)))
(EQUAL (CAR (GOPHER X))
(IF (LISTP X)
(CAR (FLATTEN X))
(ZERO)))
(EQUAL (FLATTEN (CDR (GOPHER X)))
(IF (LISTP X)
(CDR (FLATTEN X))
(CONS (ZERO)
(NIL))))
(EQUAL (QUOTIENT (TIMES Y X)
Y)
(IF (ZEROP Y)
(ZERO)
(FIX X)))
(EQUAL (GET J (SET I VAL MEM))
(IF (EQP J I)
VAL
(GET J MEM)))))))
(DE TAUTOLOGYP (X TRUE-LST FALSE-LST)
(COND ((TRUEP X TRUE-LST)
T)
((FALSEP X FALSE-LST)
NIL)
((ATOM X)
NIL)
((EQ (CAR X)
(QUOTE IF))
(COND ((TRUEP (CADR X)
TRUE-LST)
(TAUTOLOGYP (CADDR X)
TRUE-LST FALSE-LST))
((FALSEP (CADR X)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST FALSE-LST))
(T (AND (TAUTOLOGYP (CADDR X)
(CONS (CADR X)
TRUE-LST)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST
(CONS (CADR X)
FALSE-LST))))))
(T NIL)))
(DE TAUTP (X)
(TAUTOLOGYP (REWRITE X)
NIL NIL))
(DE TEST NIL
(TIMER (TEST1)))
(DE TEST1 NIL
(PROG (TERM ANS)
(SETQ TERM
(APPLY-SUBST
(QUOTE ((X F (PLUS (PLUS A B)
(PLUS C (ZERO))))
(Y F (TIMES (TIMES A B)
(PLUS C D)))
(Z F (REVERSE (APPEND (APPEND A B)
(NIL))))
(U EQUAL (PLUS A B)
(DIFFERENCE X Y))
(W LESSP (REMAINDER A B)
(MEMBER A (LENGTH B)))))
(QUOTE (IMPLIES (AND (IMPLIES X Y)
(AND (IMPLIES Y Z)
(AND (IMPLIES Z U)
(IMPLIES U W))))
(IMPLIES X W)))))
(SETQ ANS (TAUTP TERM))
(RETURN (LIST ANS))))
(DE TRANS-OF-IMPLIES (N)
(LIST (QUOTE IMPLIES)
(TRANS-OF-IMPLIES1 N)
(LIST (QUOTE IMPLIES)
0 N)))
(DE TRANS-OF-IMPLIES1 (N)
(COND ((EQUAL N 1)
(LIST (QUOTE IMPLIES)
0 1))
(T (LIST (QUOTE AND)
(LIST (QUOTE IMPLIES)
(SUB1 N)
N)
(TRANS-OF-IMPLIES1 (SUB1 N))))))
(DE TRUEP (X LST)
(OR (EQUAL X (QUOTE (T)))
(MEMBER X LST)))
(FILECREATED " 5-Jul-82 12:52:49" <CL.BOYER.LISPS>IREWRITE..4 14918
changes to: IREWRITECOMS
previous date: " 5-Jul-82 12:11:22" <CL.BOYER.LISPS>IREWRITE..3)
(PRETTYCOMPRINT IREWRITECOMS)
(RPAQQ IREWRITECOMS ((FNS * IREWRITEFNS)
(PROP BLKLIBRARYDEF MEMBER)
(BLOCKS (REWRITEBLOCK ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST
APPLY-SUBST-LST FALSEP ONE-WAY-UNIFY
ONE-WAY-UNIFY1 ONE-WAY-UNIFY1-LST PTIME
REWRITE REWRITE-ARGS REWRITE-WITH-LEMMAS
SETUP TAUTOLOGYP TAUTP TEST
TRANS-OF-IMPLIES TRANS-OF-IMPLIES1 TRUEP
(ENTRIES TEST SETUP)
(BLKLIBRARY EQUAL MEMBER GETPROP)
(GLOBALVARS TEMP-TEMP UNIFY-SUBST)))))
(RPAQQ IREWRITEFNS (ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST APPLY-SUBST-LST
FALSEP ONE-WAY-UNIFY ONE-WAY-UNIFY1
ONE-WAY-UNIFY1-LST PTIME REWRITE
REWRITE-ARGS REWRITE-WITH-LEMMAS SETUP
TAUTOLOGYP TAUTP TEST TRANS-OF-IMPLIES
TRANS-OF-IMPLIES1 TRUEP))
(DEFINEQ
(ADD-LEMMA
(LAMBDA (TERM)
(COND
((AND (NOT (ATOM TERM))
(EQ (CAR TERM)
(QUOTE EQUAL))
(NOT (ATOM (CADR TERM))))
(COND
((GETPROP (CAR (CADR TERM))
(QUOTE LEMMAS))
(PUTPROP (CAR (CADR TERM))
(QUOTE LEMMAS)
(CONS TERM (GETPROP (CAR (CADR TERM))
(QUOTE LEMMAS)))))
(T (SETPROPLIST (CAR (CADR TERM))
(CONS (QUOTE LEMMAS)
(CONS (LIST TERM)
(GETPROPLIST (CAR (CADR TERM))))))
)))
(T (ERROR (QUOTE ADD-LEMMA-DID-NOT-LIKE-TERM)
TERM)))))
(ADD-LEMMA-LST
(LAMBDA (LST)
(COND
((NULL LST)
T)
(T (ADD-LEMMA (CAR LST))
(ADD-LEMMA-LST (CDR LST))))))
(APPLY-SUBST
(LAMBDA (ALIST TERM)
(COND
((NLISTP TERM)
(COND
((SETQ TEMP-TEMP (FASSOC TERM ALIST))
(CDR TEMP-TEMP))
(T TERM)))
(T (CONS (CAR TERM)
(APPLY-SUBST-LST ALIST (CDR TERM)))))))
(APPLY-SUBST-LST
(LAMBDA (ALIST LST)
(COND
((NULL LST)
NIL)
(T (CONS (APPLY-SUBST ALIST (CAR LST))
(APPLY-SUBST-LST ALIST (CDR LST)))))))
(FALSEP
(LAMBDA (X LST)
(OR (EQUAL X (QUOTE (F)))
(MEMBER X LST))))
(ONE-WAY-UNIFY
(LAMBDA (TERM1 TERM2)
(PROGN (SETQ UNIFY-SUBST NIL)
(ONE-WAY-UNIFY1 TERM1 TERM2))))
(ONE-WAY-UNIFY1
(LAMBDA (TERM1 TERM2)
(COND
((NLISTP TERM2)
(COND
((SETQ TEMP-TEMP (FASSOC TERM2 UNIFY-SUBST))
(EQUAL TERM1 (CDR TEMP-TEMP)))
(T (SETQ UNIFY-SUBST (CONS (CONS TERM2 TERM1)
UNIFY-SUBST))
T)))
((ATOM TERM1)
NIL)
((EQ (CAR TERM1)
(CAR TERM2))
(ONE-WAY-UNIFY1-LST (CDR TERM1)
(CDR TERM2)))
(T NIL))))
(ONE-WAY-UNIFY1-LST
(LAMBDA (LST1 LST2)
(COND
((NULL LST1)
T)
((ONE-WAY-UNIFY1 (CAR LST1)
(CAR LST2))
(ONE-WAY-UNIFY1-LST (CDR LST1)
(CDR LST2)))
(T NIL))))
(PTIME
(LAMBDA NIL
(PROG (GCTM)
(SETQ GCTM (CLOCK 3))
(RETURN (CONS (IPLUS (CLOCK 2)
GCTM)
GCTM)))))
(REWRITE
(LAMBDA (TERM)
(COND
((NLISTP TERM)
TERM)
(T (REWRITE-WITH-LEMMAS (CONS (CAR TERM)
(REWRITE-ARGS (CDR TERM)))
(GETPROP (CAR TERM)
(QUOTE LEMMAS)))))))
(REWRITE-ARGS
(LAMBDA (LST)
(COND
((NULL LST)
NIL)
(T (CONS (REWRITE (CAR LST))
(REWRITE-ARGS (CDR LST)))))))
(REWRITE-WITH-LEMMAS
(LAMBDA (TERM LST)
(COND
((NULL LST)
TERM)
((ONE-WAY-UNIFY TERM (CADR (CAR LST)))
(REWRITE (APPLY-SUBST UNIFY-SUBST (CADDR (CAR LST)))))
(T (REWRITE-WITH-LEMMAS TERM (CDR LST))))))
(SETUP
(LAMBDA NIL
(ADD-LEMMA-LST
(QUOTE
((EQUAL (COMPILE FORM)
(REVERSE (CODEGEN (OPTIMIZE FORM)
(NIL))))
(EQUAL (EQP X Y)
(EQUAL (FIX X)
(FIX Y)))
(EQUAL (GREATERP X Y)
(LESSP Y X))
(EQUAL (LESSEQP X Y)
(NOT (LESSP Y X)))
(EQUAL (GREATEREQP X Y)
(NOT (LESSP X Y)))
(EQUAL (BOOLEAN X)
(OR (EQUAL X (T))
(EQUAL X (F))))
(EQUAL (IFF X Y)
(AND (IMPLIES X Y)
(IMPLIES Y X)))
(EQUAL (EVEN1 X)
(IF (ZEROP X)
(T)
(ODD (SUB1 X))))
(EQUAL (COUNTPS- L PRED)
(COUNTPS-LOOP L PRED (ZERO)))
(EQUAL (FACT- I)
(FACT-LOOP I 1))
(EQUAL (REVERSE- X)
(REVERSE-LOOP X (NIL)))
(EQUAL (DIVIDES X Y)
(ZEROP (REMAINDER Y X)))
(EQUAL (ASSUME-TRUE VAR ALIST)
(CONS (CONS VAR (T))
ALIST))
(EQUAL (ASSUME-FALSE VAR ALIST)
(CONS (CONS VAR (F))
ALIST))
(EQUAL (TAUTOLOGY-CHECKER X)
(TAUTOLOGYP (NORMALIZE X)
(NIL)))
(EQUAL (FALSIFY X)
(FALSIFY1 (NORMALIZE X)
(NIL)))
(EQUAL (PRIME X)
(AND (NOT (ZEROP X))
(NOT (EQUAL X (ADD1 (ZERO))))
(PRIME1 X (SUB1 X))))
(EQUAL (AND P Q)
(IF P (IF Q (T)
(F))
(F)))
(EQUAL (OR P Q)
(IF P (T)
(IF Q (T)
(F))
(F)))
(EQUAL (NOT P)
(IF P (F)
(T)))
(EQUAL (IMPLIES P Q)
(IF P (IF Q (T)
(F))
(T)))
(EQUAL (FIX X)
(IF (NUMBERP X)
X
(ZERO)))
(EQUAL (IF (IF A B C)
D E)
(IF A (IF B D E)
(IF C D E)))
(EQUAL (ZEROP X)
(OR (EQUAL X (ZERO))
(NOT (NUMBERP X))))
(EQUAL (PLUS (PLUS X Y)
Z)
(PLUS X (PLUS Y Z)))
(EQUAL (EQUAL (PLUS A B)
(ZERO))
(AND (ZEROP A)
(ZEROP B)))
(EQUAL (DIFFERENCE X X)
(ZERO))
(EQUAL (EQUAL (PLUS A B)
(PLUS A C))
(EQUAL (FIX B)
(FIX C)))
(EQUAL (EQUAL (ZERO)
(DIFFERENCE X Y))
(NOT (LESSP Y X)))
(EQUAL (EQUAL X (DIFFERENCE X Y))
(AND (NUMBERP X)
(OR (EQUAL X (ZERO))
(ZEROP Y))))
(EQUAL (MEANING (PLUS-TREE (APPEND X Y))
A)
(PLUS (MEANING (PLUS-TREE X)
A)
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (MEANING (PLUS-TREE (PLUS-FRINGE X))
A)
(FIX (MEANING X A)))
(EQUAL (APPEND (APPEND X Y)
Z)
(APPEND X (APPEND Y Z)))
(EQUAL (REVERSE (APPEND A B))
(APPEND (REVERSE B)
(REVERSE A)))
(EQUAL (TIMES X (PLUS Y Z))
(PLUS (TIMES X Y)
(TIMES X Z)))
(EQUAL (TIMES (TIMES X Y)
Z)
(TIMES X (TIMES Y Z)))
(EQUAL (EQUAL (TIMES X Y)
(ZERO))
(OR (ZEROP X)
(ZEROP Y)))
(EQUAL (EXEC (APPEND X Y)
PDS ENVRN)
(EXEC Y (EXEC X PDS ENVRN)
ENVRN))
(EQUAL (MC-FLATTEN X Y)
(APPEND (FLATTEN X)
Y))
(EQUAL (MEMBER X (APPEND A B))
(OR (MEMBER X A)
(MEMBER X B)))
(EQUAL (MEMBER X (REVERSE Y))
(MEMBER X Y))
(EQUAL (LENGTH (REVERSE X))
(LENGTH X))
(EQUAL (MEMBER A (INTERSECT B C))
(AND (MEMBER A B)
(MEMBER A C)))
(EQUAL (NTH (ZERO)
I)
(ZERO))
(EQUAL (EXP I (PLUS J K))
(TIMES (EXP I J)
(EXP I K)))
(EQUAL (EXP I (TIMES J K))
(EXP (EXP I J)
K))
(EQUAL (REVERSE-LOOP X Y)
(APPEND (REVERSE X)
Y))
(EQUAL (REVERSE-LOOP X (NIL))
(REVERSE X))
(EQUAL (COUNT-LIST Z (SORT-LP X Y))
(PLUS (COUNT-LIST Z X)
(COUNT-LIST Z Y)))
(EQUAL (EQUAL (APPEND A B)
(APPEND A C))
(EQUAL B C))
(EQUAL (PLUS (REMAINDER X Y)
(TIMES Y (QUOTIENT X Y)))
(FIX X))
(EQUAL (POWER-EVAL (BIG-PLUS1 L I BASE)
BASE)
(PLUS (POWER-EVAL L BASE)
I))
(EQUAL (POWER-EVAL (BIG-PLUS X Y I BASE)
BASE)
(PLUS I (PLUS (POWER-EVAL X BASE)
(POWER-EVAL Y BASE))))
(EQUAL (REMAINDER Y 1)
(ZERO))
(EQUAL (LESSP (REMAINDER X Y)
Y)
(NOT (ZEROP Y)))
(EQUAL (REMAINDER X X)
(ZERO))
(EQUAL (LESSP (QUOTIENT I J)
I)
(AND (NOT (ZEROP I))
(OR (ZEROP J)
(NOT (EQUAL J 1)))))
(EQUAL (LESSP (REMAINDER X Y)
X)
(AND (NOT (ZEROP Y))
(NOT (ZEROP X))
(NOT (LESSP X Y))))
(EQUAL (POWER-EVAL (POWER-REP I BASE)
BASE)
(FIX I))
(EQUAL (POWER-EVAL (BIG-PLUS (POWER-REP I BASE)
(POWER-REP J BASE)
(ZERO)
BASE)
BASE)
(PLUS I J))
(EQUAL (GCD X Y)
(GCD Y X))
(EQUAL (NTH (APPEND A B)
I)
(APPEND (NTH A I)
(NTH B (DIFFERENCE I (LENGTH A)))))
(EQUAL (DIFFERENCE (PLUS X Y)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS Y X)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS X Y)
(PLUS X Z))
(DIFFERENCE Y Z))
(EQUAL (TIMES X (DIFFERENCE C W))
(DIFFERENCE (TIMES C X)
(TIMES W X)))
(EQUAL (REMAINDER (TIMES X Z)
Z)
(ZERO))
(EQUAL (DIFFERENCE (PLUS B (PLUS A C))
A)
(PLUS B C))
(EQUAL (DIFFERENCE (ADD1 (PLUS Y Z))
Z)
(ADD1 Y))
(EQUAL (LESSP (PLUS X Y)
(PLUS X Z))
(LESSP Y Z))
(EQUAL (LESSP (TIMES X Z)
(TIMES Y Z))
(AND (NOT (ZEROP Z))
(LESSP X Y)))
(EQUAL (LESSP Y (PLUS X Y))
(NOT (ZEROP X)))
(EQUAL (GCD (TIMES X Z)
(TIMES Y Z))
(TIMES Z (GCD X Y)))
(EQUAL (VALUE (NORMALIZE X)
A)
(VALUE X A))
(EQUAL (EQUAL (FLATTEN X)
(CONS Y (NIL)))
(AND (NLISTP X)
(EQUAL X Y)))
(EQUAL (LISTP (GOPHER X))
(LISTP X))
(EQUAL (SAMEFRINGE X Y)
(EQUAL (FLATTEN X)
(FLATTEN Y)))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
(ZERO))
(AND (OR (ZEROP Y)
(EQUAL Y 1))
(EQUAL X (ZERO))))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
1)
(EQUAL X 1))
(EQUAL (NUMBERP (GREATEST-FACTOR X Y))
(NOT (AND (OR (ZEROP Y)
(EQUAL Y 1))
(NOT (NUMBERP X)))))
(EQUAL (TIMES-LIST (APPEND X Y))
(TIMES (TIMES-LIST X)
(TIMES-LIST Y)))
(EQUAL (PRIME-LIST (APPEND X Y))
(AND (PRIME-LIST X)
(PRIME-LIST Y)))
(EQUAL (EQUAL Z (TIMES W Z))
(AND (NUMBERP Z)
(OR (EQUAL Z (ZERO))
(EQUAL W 1))))
(EQUAL (GREATEREQPR X Y)
(NOT (LESSP X Y)))
(EQUAL (EQUAL X (TIMES X Y))
(OR (EQUAL X (ZERO))
(AND (NUMBERP X)
(EQUAL Y 1))))
(EQUAL (REMAINDER (TIMES Y X)
Y)
(ZERO))
(EQUAL (EQUAL (TIMES A B)
1)
(AND (NOT (EQUAL A (ZERO)))
(NOT (EQUAL B (ZERO)))
(NUMBERP A)
(NUMBERP B)
(EQUAL (SUB1 A)
(ZERO))
(EQUAL (SUB1 B)
(ZERO))))
(EQUAL (LESSP (LENGTH (DELETE X L))
(LENGTH L))
(MEMBER X L))
(EQUAL (SORT2 (DELETE X L))
(DELETE X (SORT2 L)))
(EQUAL (DSORT X)
(SORT2 X))
(EQUAL
(LENGTH (CONS X1
(CONS X2
(CONS X3
(CONS X4 (CONS X5
(CONS X6 X7)))))))
(PLUS 6 (LENGTH X7)))
(EQUAL (DIFFERENCE (ADD1 (ADD1 X))
2)
(FIX X))
(EQUAL (QUOTIENT (PLUS X (PLUS X Y))
2)
(PLUS X (QUOTIENT Y 2)))
(EQUAL (SIGMA (ZERO)
I)
(QUOTIENT (TIMES I (ADD1 I))
2))
(EQUAL (PLUS X (ADD1 Y))
(IF (NUMBERP Y)
(ADD1 (PLUS X Y))
(ADD1 X)))
(EQUAL (EQUAL (DIFFERENCE X Y)
(DIFFERENCE Z Y))
(IF (LESSP X Y)
(NOT (LESSP Y Z))
(IF (LESSP Z Y)
(NOT (LESSP Y X))
(EQUAL (FIX X)
(FIX Z)))))
(EQUAL (MEANING (PLUS-TREE (DELETE X Y))
A)
(IF (MEMBER X Y)
(DIFFERENCE (MEANING (PLUS-TREE Y)
A)
(MEANING X A))
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (TIMES X (ADD1 Y))
(IF (NUMBERP Y)
(PLUS X (TIMES X Y))
(FIX X)))
(EQUAL (NTH (NIL)
I)
(IF (ZEROP I)
(NIL)
(ZERO)))
(EQUAL (LAST (APPEND A B))
(IF (LISTP B)
(LAST B)
(IF (LISTP A)
(CONS (CAR (LAST A))
B)
B)))
(EQUAL (EQUAL (LESSP X Y)
Z)
(IF (LESSP X Y)
(EQUAL T Z)
(EQUAL F Z)))
(EQUAL (ASSIGNMENT X (APPEND A B))
(IF (ASSIGNEDP X A)
(ASSIGNMENT X A)
(ASSIGNMENT X B)))
(EQUAL (CAR (GOPHER X))
(IF (LISTP X)
(CAR (FLATTEN X))
(ZERO)))
(EQUAL (FLATTEN (CDR (GOPHER X)))
(IF (LISTP X)
(CDR (FLATTEN X))
(CONS (ZERO)
(NIL))))
(EQUAL (QUOTIENT (TIMES Y X)
Y)
(IF (ZEROP Y)
(ZERO)
(FIX X)))
(EQUAL (GET J (SET I VAL MEM))
(IF (EQP J I)
VAL
(GET J MEM))))))))
(TAUTOLOGYP
(LAMBDA (X TRUE-LST FALSE-LST)
(COND
((TRUEP X TRUE-LST)
T)
((FALSEP X FALSE-LST)
NIL)
((NLISTP X)
NIL)
((EQ (CAR X)
(QUOTE IF))
(COND
((TRUEP (CADR X)
TRUE-LST)
(TAUTOLOGYP (CADDR X)
TRUE-LST FALSE-LST))
((FALSEP (CADR X)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST FALSE-LST))
(T (AND (TAUTOLOGYP (CADDR X)
(CONS (CADR X)
TRUE-LST)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST
(CONS (CADR X)
FALSE-LST))))))
(T NIL))))
(TAUTP
(LAMBDA (X)
(TAUTOLOGYP (REWRITE X)
NIL NIL)))
(TEST
(LAMBDA NIL
(PROG (TM1 TM2 ANS TERM)
(SETQ TM1 (PTIME))
(SETQ TERM
(APPLY-SUBST
(QUOTE ((X F (PLUS (PLUS A B)
(PLUS C (ZERO))))
(Y F (TIMES (TIMES A B)
(PLUS C D)))
(Z F (REVERSE (APPEND (APPEND A B)
(NIL))))
(U EQUAL (PLUS A B)
(DIFFERENCE X Y))
(W LESSP (REMAINDER A B)
(MEMBER A (LENGTH B)))))
(QUOTE (IMPLIES (AND (IMPLIES X Y)
(AND (IMPLIES Y Z)
(AND (IMPLIES Z U)
(IMPLIES U W))))
(IMPLIES X W)))))
(SETQ ANS (TAUTP TERM))
(SETQ TM2 (PTIME))
(RETURN (LIST ANS (DIFFERENCE (CAR TM2)
(CAR TM1))
(DIFFERENCE (CDR TM2)
(CDR TM1)))))))
(TRANS-OF-IMPLIES
(LAMBDA (N)
(LIST (QUOTE IMPLIES)
(TRANS-OF-IMPLIES1 N)
(LIST (QUOTE IMPLIES)
0 N))))
(TRANS-OF-IMPLIES1
(LAMBDA (N)
(COND
((EQUAL N 1)
(LIST (QUOTE IMPLIES)
0 1))
(T (LIST (QUOTE AND)
(LIST (QUOTE IMPLIES)
(SUB1 N)
N)
(TRANS-OF-IMPLIES1 (SUB1 N)))))))
(TRUEP
(LAMBDA (X LST)
(OR (EQUAL X (QUOTE (T)))
(MEMBER X LST))))
)
(PUTPROPS MEMBER BLKLIBRARYDEF (LAMBDA
(.BLKVAR.X .BLKVAR.Y)
(DECLARE (LOCALVARS . T))
(PROG NIL LP (RETURN (COND ((NLISTP .BLKVAR.Y)
NIL)
((EQUAL .BLKVAR.X (CAR .BLKVAR.Y)
)
.BLKVAR.Y)
(T (SETQ .BLKVAR.Y (CDR
.BLKVAR.Y))
(GO LP)))))))
[DECLARE: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY
(BLOCK: REWRITEBLOCK ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST
APPLY-SUBST-LST FALSEP ONE-WAY-UNIFY ONE-WAY-UNIFY1
ONE-WAY-UNIFY1-LST PTIME REWRITE REWRITE-ARGS
REWRITE-WITH-LEMMAS SETUP TAUTOLOGYP TAUTP TEST
TRANS-OF-IMPLIES TRANS-OF-IMPLIES1 TRUEP (ENTRIES TEST SETUP)
(BLKLIBRARY EQUAL MEMBER GETPROP)
(GLOBALVARS TEMP-TEMP UNIFY-SUBST))
]
(DECLARE: DONTCOPY
(FILEMAP (NIL (1018 14165 (ADD-LEMMA 1030 . 1573) (ADD-LEMMA-LST 1577 .
1708) (APPLY-SUBST 1712 . 1945) (APPLY-SUBST-LST 1949 . 2119) (FALSEP
2123 . 2200) (ONE-WAY-UNIFY 2204 . 2315) (ONE-WAY-UNIFY1 2319 . 2717) (
ONE-WAY-UNIFY1-LST 2721 . 2928) (PTIME 2932 . 3077) (REWRITE 3081 . 3295
) (REWRITE-ARGS 3299 . 3441) (REWRITE-WITH-LEMMAS 3445 . 3679) (SETUP
3683 . 12295) (TAUTOLOGYP 12299 . 12890) (TAUTP 12894 . 12958) (TEST
12962 . 13720) (TRANS-OF-IMPLIES 13724 . 13846) (TRANS-OF-IMPLIES1 13850
. 14082) (TRUEP 14086 . 14162)))))
STOP
The Maclisp Code
(DECLARE (SPECIAL UNIFY-SUBST TEMP-TEMP))
(DEFUN PTIME NIL (LIST (RUNTIME) (STATUS GCTIME)))
(DEFUN ADD-LEMMA (TERM)
(COND ((AND (NOT (ATOM TERM))
(EQ (CAR TERM)
(QUOTE EQUAL))
(NOT (ATOM (CADR TERM))))
(PUTPROP (CAR (CADR TERM))
(CONS TERM (GET (CAR (CADR TERM))
(QUOTE LEMMAS)))
(QUOTE LEMMAS)))
(T (ERROR (QUOTE ADD-LEMMA-DID-NOT-LIKE-TERM)
TERM))))
(DEFUN ADD-LEMMA-LST (LST)
(COND ((NULL LST)
T)
(T (ADD-LEMMA (CAR LST))
(ADD-LEMMA-LST (CDR LST)))))
(DEFUN APPLY-SUBST (ALIST TERM)
(COND ((ATOM TERM)
(COND ((SETQ TEMP-TEMP (ASSQ TERM ALIST))
(CDR TEMP-TEMP))
(T TERM)))
(T (CONS (CAR TERM)
(APPLY-SUBST-LST ALIST (CDR TERM))))))
(DEFUN APPLY-SUBST-LST (ALIST LST)
(COND ((NULL LST)
NIL)
(T (CONS (APPLY-SUBST ALIST (CAR LST))
(APPLY-SUBST-LST ALIST (CDR LST))))))
(DEFUN FALSEP (X LST)
(OR (EQUAL X (QUOTE (F)))
(MEMBER X LST)))
(DEFUN ONE-WAY-UNIFY (TERM1 TERM2)
(PROGN (SETQ UNIFY-SUBST NIL)
(ONE-WAY-UNIFY1 TERM1 TERM2)))
(DEFUN ONE-WAY-UNIFY1 (TERM1 TERM2)
(COND ((ATOM TERM2)
(COND ((SETQ TEMP-TEMP (ASSQ TERM2 UNIFY-SUBST))
(EQUAL TERM1 (CDR TEMP-TEMP)))
(T (SETQ UNIFY-SUBST (CONS (CONS TERM2 TERM1)
UNIFY-SUBST))
T)))
((ATOM TERM1)
NIL)
((EQ (CAR TERM1)
(CAR TERM2))
(ONE-WAY-UNIFY1-LST (CDR TERM1)
(CDR TERM2)))
(T NIL)))
(DEFUN ONE-WAY-UNIFY1-LST (LST1 LST2)
(COND ((NULL LST1)
T)
((ONE-WAY-UNIFY1 (CAR LST1)
(CAR LST2))
(ONE-WAY-UNIFY1-LST (CDR LST1)
(CDR LST2)))
(T NIL)))
(DEFUN REWRITE (TERM)
(COND ((ATOM TERM)
TERM)
(T (REWRITE-WITH-LEMMAS (CONS (CAR TERM)
(REWRITE-ARGS (CDR TERM)))
(GET (CAR TERM)
(QUOTE LEMMAS))))))
(DEFUN REWRITE-ARGS (LST)
(COND ((NULL LST)
NIL)
(T (CONS (REWRITE (CAR LST))
(REWRITE-ARGS (CDR LST))))))
(DEFUN REWRITE-WITH-LEMMAS (TERM LST)
(COND ((NULL LST)
TERM)
((ONE-WAY-UNIFY TERM (CADR (CAR LST)))
(REWRITE (APPLY-SUBST UNIFY-SUBST (CADDR (CAR LST)))))
(T (REWRITE-WITH-LEMMAS TERM (CDR LST)))))
(DEFUN
SETUP NIL
(ADD-LEMMA-LST
(QUOTE ((EQUAL (COMPILE FORM)
(REVERSE (CODEGEN (OPTIMIZE FORM)
(NIL))))
(EQUAL (EQP X Y)
(EQUAL (FIX X)
(FIX Y)))
(EQUAL (GREATERP X Y)
(LESSP Y X))
(EQUAL (LESSEQP X Y)
(NOT (LESSP Y X)))
(EQUAL (GREATEREQP X Y)
(NOT (LESSP X Y)))
(EQUAL (BOOLEAN X)
(OR (EQUAL X (T))
(EQUAL X (F))))
(EQUAL (IFF X Y)
(AND (IMPLIES X Y)
(IMPLIES Y X)))
(EQUAL (EVEN1 X)
(IF (ZEROP X)
(T)
(ODD (SUB1 X))))
(EQUAL (COUNTPS- L PRED)
(COUNTPS-LOOP L PRED (ZERO)))
(EQUAL (FACT- I)
(FACT-LOOP I 1))
(EQUAL (REVERSE- X)
(REVERSE-LOOP X (NIL)))
(EQUAL (DIVIDES X Y)
(ZEROP (REMAINDER Y X)))
(EQUAL (ASSUME-TRUE VAR ALIST)
(CONS (CONS VAR (T))
ALIST))
(EQUAL (ASSUME-FALSE VAR ALIST)
(CONS (CONS VAR (F))
ALIST))
(EQUAL (TAUTOLOGY-CHECKER X)
(TAUTOLOGYP (NORMALIZE X)
(NIL)))
(EQUAL (FALSIFY X)
(FALSIFY1 (NORMALIZE X)
(NIL)))
(EQUAL (PRIME X)
(AND (NOT (ZEROP X))
(NOT (EQUAL X (ADD1 (ZERO))))
(PRIME1 X (SUB1 X))))
(EQUAL (AND P Q)
(IF P (IF Q (T)
(F))
(F)))
(EQUAL (OR P Q)
(IF P (T)
(IF Q (T)
(F))
(F)))
(EQUAL (NOT P)
(IF P (F)
(T)))
(EQUAL (IMPLIES P Q)
(IF P (IF Q (T)
(F))
(T)))
(EQUAL (FIX X)
(IF (NUMBERP X)
X
(ZERO)))
(EQUAL (IF (IF A B C)
D E)
(IF A (IF B D E)
(IF C D E)))
(EQUAL (ZEROP X)
(OR (EQUAL X (ZERO))
(NOT (NUMBERP X))))
(EQUAL (PLUS (PLUS X Y)
Z)
(PLUS X (PLUS Y Z)))
(EQUAL (EQUAL (PLUS A B)
(ZERO))
(AND (ZEROP A)
(ZEROP B)))
(EQUAL (DIFFERENCE X X)
(ZERO))
(EQUAL (EQUAL (PLUS A B)
(PLUS A C))
(EQUAL (FIX B)
(FIX C)))
(EQUAL (EQUAL (ZERO)
(DIFFERENCE X Y))
(NOT (LESSP Y X)))
(EQUAL (EQUAL X (DIFFERENCE X Y))
(AND (NUMBERP X)
(OR (EQUAL X (ZERO))
(ZEROP Y))))
(EQUAL (MEANING (PLUS-TREE (APPEND X Y))
A)
(PLUS (MEANING (PLUS-TREE X)
A)
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (MEANING (PLUS-TREE (PLUS-FRINGE X))
A)
(FIX (MEANING X A)))
(EQUAL (APPEND (APPEND X Y)
Z)
(APPEND X (APPEND Y Z)))
(EQUAL (REVERSE (APPEND A B))
(APPEND (REVERSE B)
(REVERSE A)))
(EQUAL (TIMES X (PLUS Y Z))
(PLUS (TIMES X Y)
(TIMES X Z)))
(EQUAL (TIMES (TIMES X Y)
Z)
(TIMES X (TIMES Y Z)))
(EQUAL (EQUAL (TIMES X Y)
(ZERO))
(OR (ZEROP X)
(ZEROP Y)))
(EQUAL (EXEC (APPEND X Y)
PDS ENVRN)
(EXEC Y (EXEC X PDS ENVRN)
ENVRN))
(EQUAL (MC-FLATTEN X Y)
(APPEND (FLATTEN X)
Y))
(EQUAL (MEMBER X (APPEND A B))
(OR (MEMBER X A)
(MEMBER X B)))
(EQUAL (MEMBER X (REVERSE Y))
(MEMBER X Y))
(EQUAL (LENGTH (REVERSE X))
(LENGTH X))
(EQUAL (MEMBER A (INTERSECT B C))
(AND (MEMBER A B)
(MEMBER A C)))
(EQUAL (NTH (ZERO)
I)
(ZERO))
(EQUAL (EXP I (PLUS J K))
(TIMES (EXP I J)
(EXP I K)))
(EQUAL (EXP I (TIMES J K))
(EXP (EXP I J)
K))
(EQUAL (REVERSE-LOOP X Y)
(APPEND (REVERSE X)
Y))
(EQUAL (REVERSE-LOOP X (NIL))
(REVERSE X))
(EQUAL (COUNT-LIST Z (SORT-LP X Y))
(PLUS (COUNT-LIST Z X)
(COUNT-LIST Z Y)))
(EQUAL (EQUAL (APPEND A B)
(APPEND A C))
(EQUAL B C))
(EQUAL (PLUS (REMAINDER X Y)
(TIMES Y (QUOTIENT X Y)))
(FIX X))
(EQUAL (POWER-EVAL (BIG-PLUS1 L I BASE)
BASE)
(PLUS (POWER-EVAL L BASE)
I))
(EQUAL (POWER-EVAL (BIG-PLUS X Y I BASE)
BASE)
(PLUS I (PLUS (POWER-EVAL X BASE)
(POWER-EVAL Y BASE))))
(EQUAL (REMAINDER Y 1)
(ZERO))
(EQUAL (LESSP (REMAINDER X Y)
Y)
(NOT (ZEROP Y)))
(EQUAL (REMAINDER X X)
(ZERO))
(EQUAL (LESSP (QUOTIENT I J)
I)
(AND (NOT (ZEROP I))
(OR (ZEROP J)
(NOT (EQUAL J 1)))))
(EQUAL (LESSP (REMAINDER X Y)
X)
(AND (NOT (ZEROP Y))
(NOT (ZEROP X))
(NOT (LESSP X Y))))
(EQUAL (POWER-EVAL (POWER-REP I BASE)
BASE)
(FIX I))
(EQUAL (POWER-EVAL (BIG-PLUS (POWER-REP I BASE)
(POWER-REP J BASE)
(ZERO)
BASE)
BASE)
(PLUS I J))
(EQUAL (GCD X Y)
(GCD Y X))
(EQUAL (NTH (APPEND A B)
I)
(APPEND (NTH A I)
(NTH B (DIFFERENCE I (LENGTH A)))))
(EQUAL (DIFFERENCE (PLUS X Y)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS Y X)
X)
(FIX Y))
(EQUAL (DIFFERENCE (PLUS X Y)
(PLUS X Z))
(DIFFERENCE Y Z))
(EQUAL (TIMES X (DIFFERENCE C W))
(DIFFERENCE (TIMES C X)
(TIMES W X)))
(EQUAL (REMAINDER (TIMES X Z)
Z)
(ZERO))
(EQUAL (DIFFERENCE (PLUS B (PLUS A C))
A)
(PLUS B C))
(EQUAL (DIFFERENCE (ADD1 (PLUS Y Z))
Z)
(ADD1 Y))
(EQUAL (LESSP (PLUS X Y)
(PLUS X Z))
(LESSP Y Z))
(EQUAL (LESSP (TIMES X Z)
(TIMES Y Z))
(AND (NOT (ZEROP Z))
(LESSP X Y)))
(EQUAL (LESSP Y (PLUS X Y))
(NOT (ZEROP X)))
(EQUAL (GCD (TIMES X Z)
(TIMES Y Z))
(TIMES Z (GCD X Y)))
(EQUAL (VALUE (NORMALIZE X)
A)
(VALUE X A))
(EQUAL (EQUAL (FLATTEN X)
(CONS Y (NIL)))
(AND (NLISTP X)
(EQUAL X Y)))
(EQUAL (LISTP (GOPHER X))
(LISTP X))
(EQUAL (SAMEFRINGE X Y)
(EQUAL (FLATTEN X)
(FLATTEN Y)))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
(ZERO))
(AND (OR (ZEROP Y)
(EQUAL Y 1))
(EQUAL X (ZERO))))
(EQUAL (EQUAL (GREATEST-FACTOR X Y)
1)
(EQUAL X 1))
(EQUAL (NUMBERP (GREATEST-FACTOR X Y))
(NOT (AND (OR (ZEROP Y)
(EQUAL Y 1))
(NOT (NUMBERP X)))))
(EQUAL (TIMES-LIST (APPEND X Y))
(TIMES (TIMES-LIST X)
(TIMES-LIST Y)))
(EQUAL (PRIME-LIST (APPEND X Y))
(AND (PRIME-LIST X)
(PRIME-LIST Y)))
(EQUAL (EQUAL Z (TIMES W Z))
(AND (NUMBERP Z)
(OR (EQUAL Z (ZERO))
(EQUAL W 1))))
(EQUAL (GREATEREQPR X Y)
(NOT (LESSP X Y)))
(EQUAL (EQUAL X (TIMES X Y))
(OR (EQUAL X (ZERO))
(AND (NUMBERP X)
(EQUAL Y 1))))
(EQUAL (REMAINDER (TIMES Y X)
Y)
(ZERO))
(EQUAL (EQUAL (TIMES A B)
1)
(AND (NOT (EQUAL A (ZERO)))
(NOT (EQUAL B (ZERO)))
(NUMBERP A)
(NUMBERP B)
(EQUAL (SUB1 A)
(ZERO))
(EQUAL (SUB1 B)
(ZERO))))
(EQUAL (LESSP (LENGTH (DELETE X L))
(LENGTH L))
(MEMBER X L))
(EQUAL (SORT2 (DELETE X L))
(DELETE X (SORT2 L)))
(EQUAL (DSORT X)
(SORT2 X))
(EQUAL (LENGTH (CONS X1
(CONS X2
(CONS X3 (CONS X4
(CONS X5
(CONS X6 X7)))))))
(PLUS 6 (LENGTH X7)))
(EQUAL (DIFFERENCE (ADD1 (ADD1 X))
2)
(FIX X))
(EQUAL (QUOTIENT (PLUS X (PLUS X Y))
2)
(PLUS X (QUOTIENT Y 2)))
(EQUAL (SIGMA (ZERO)
I)
(QUOTIENT (TIMES I (ADD1 I))
2))
(EQUAL (PLUS X (ADD1 Y))
(IF (NUMBERP Y)
(ADD1 (PLUS X Y))
(ADD1 X)))
(EQUAL (EQUAL (DIFFERENCE X Y)
(DIFFERENCE Z Y))
(IF (LESSP X Y)
(NOT (LESSP Y Z))
(IF (LESSP Z Y)
(NOT (LESSP Y X))
(EQUAL (FIX X)
(FIX Z)))))
(EQUAL (MEANING (PLUS-TREE (DELETE X Y))
A)
(IF (MEMBER X Y)
(DIFFERENCE (MEANING (PLUS-TREE Y)
A)
(MEANING X A))
(MEANING (PLUS-TREE Y)
A)))
(EQUAL (TIMES X (ADD1 Y))
(IF (NUMBERP Y)
(PLUS X (TIMES X Y))
(FIX X)))
(EQUAL (NTH (NIL)
I)
(IF (ZEROP I)
(NIL)
(ZERO)))
(EQUAL (LAST (APPEND A B))
(IF (LISTP B)
(LAST B)
(IF (LISTP A)
(CONS (CAR (LAST A))
B)
B)))
(EQUAL (EQUAL (LESSP X Y)
Z)
(IF (LESSP X Y)
(EQUAL T Z)
(EQUAL F Z)))
(EQUAL (ASSIGNMENT X (APPEND A B))
(IF (ASSIGNEDP X A)
(ASSIGNMENT X A)
(ASSIGNMENT X B)))
(EQUAL (CAR (GOPHER X))
(IF (LISTP X)
(CAR (FLATTEN X))
(ZERO)))
(EQUAL (FLATTEN (CDR (GOPHER X)))
(IF (LISTP X)
(CDR (FLATTEN X))
(CONS (ZERO)
(NIL))))
(EQUAL (QUOTIENT (TIMES Y X)
Y)
(IF (ZEROP Y)
(ZERO)
(FIX X)))
(EQUAL (GET J (SET I VAL MEM))
(IF (EQP J I)
VAL
(GET J MEM)))))))
(DEFUN TAUTOLOGYP (X TRUE-LST FALSE-LST)
(COND ((TRUEP X TRUE-LST)
T)
((FALSEP X FALSE-LST)
NIL)
((ATOM X)
NIL)
((EQ (CAR X)
(QUOTE IF))
(COND ((TRUEP (CADR X)
TRUE-LST)
(TAUTOLOGYP (CADDR X)
TRUE-LST FALSE-LST))
((FALSEP (CADR X)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST FALSE-LST))
(T (AND (TAUTOLOGYP (CADDR X)
(CONS (CADR X)
TRUE-LST)
FALSE-LST)
(TAUTOLOGYP (CADDDR X)
TRUE-LST
(CONS (CADR X)
FALSE-LST))))))
(T NIL)))
(DEFUN TAUTP (X)
(TAUTOLOGYP (REWRITE X)
NIL NIL))
(DEFUN TEST NIL
(PROG (TM1 TM2 ANS TERM)
(SETQ TM1 (PTIME))
(SETQ TERM
(APPLY-SUBST
(QUOTE ((X F (PLUS (PLUS A B)
(PLUS C (ZERO))))
(Y F (TIMES (TIMES A B)
(PLUS C D)))
(Z F (REVERSE (APPEND (APPEND A B)
(NIL))))
(U EQUAL (PLUS A B)
(DIFFERENCE X Y))
(W LESSP (REMAINDER A B)
(MEMBER A (LENGTH B)))))
(QUOTE (IMPLIES (AND (IMPLIES X Y)
(AND (IMPLIES Y Z)
(AND (IMPLIES Z U)
(IMPLIES U W))))
(IMPLIES X W)))))
(SETQ ANS (TAUTP TERM))
(SETQ TM2 (PTIME))
(RETURN (LIST ANS (DIFFERENCE (CAR TM2)
(CAR TM1))
(DIFFERENCE (CADR TM2)
(CADR TM1))))))
(DEFUN TRANS-OF-IMPLIES (N)
(LIST (QUOTE IMPLIES)
(TRANS-OF-IMPLIES1 N)
(LIST (QUOTE IMPLIES)
0 N)))
(DEFUN TRANS-OF-IMPLIES1 (N)
(COND ((EQUAL N 1)
(LIST (QUOTE IMPLIES)
0 1))
(T (LIST (QUOTE AND)
(LIST (QUOTE IMPLIES)
(SUB1 N)
N)
(TRANS-OF-IMPLIES1 (SUB1 N))))))
(DEFUN TRUEP (X LST)
(OR (EQUAL X (QUOTE (T)))
(MEMBER X LST)))
The ELISP test
[PHOTO: Recording initiated Tue 29-Jun-82 12:23PM]
LINK FROM CL.BOYER, TTY 17
Tops-20 Command Processor 4A(67)-1
End of <CL.BOYER>COMAND.CMD.1
@<ELISP>ELISP
[Keeping]
Elisp, 4 27 82
*(DSKIN "EREWRITE.FLAP")
"EREWRITE.FLAP.2"
Files-Loaded
*(SETUP)
T
*(TEST)
19776 msec CPU (7447 msec GC), 41583 msec clock, 452930 words consed
(T)
*(TEST)
18185 msec CPU (6361 msec GC), 51621 msec clock, 452930 words consed
(T)
*↑C
@POP
[PHOTO: Recording terminated Tue 29-Jun-82 12:26PM]
Interlisp bcompl blocklib swap and noswap
[PHOTO: Recording initiated Mon 5-Jul-82 12:16PM]
LINK FROM CL.BOYER, TTY 17
Tops-20 Command Processor 4B(70)-1
End of <CL.BOYER>COMAND.CMD.1
@LISP.EXE.133
INTERLISP-10 27-NOV-79 ...
collecting lists
716, 10444 free cells
control-A is an interrupt and can't be an edit control-character
Good afternoon, Bob.
2←LOAD(IREWRITE.COM]
compiled on 5-Jul-82 12:11:29
FILE CREATED 5-Jul-82 12:11:22
IREWRITECOMS
<CL.BOYER.LISPS>IREWRITE.COM.3
3←IREWRITECOMS
((FNS * IREWRITEFNS) (PROP BLKLIBRARYDEF MEMBER SASSOC) (BLOCKS (REWRITEBLOCK
ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST APPLY-SUBST-LST FALSEP ONE-WAY-UNIFY
ONE-WAY-UNIFY1 ONE-WAY-UNIFY1-LST PTIME REWRITE REWRITE-ARGS REWRITE-WITH-LEMMAS
SETUP TAUTOLOGYP TAUTP TEST TRANS-OF-IMPLIES TRANS-OF-IMPLIES1 TRUEP (ENTRIES
TEST SETUP) (BLKLIBRARY EQUAL MEMBER GETPROP) (GLOBALVARS TEMP-TEMP UNIFY-SUBST)
)))
4←NOSWAPFLG
NIL
5←(MINFS 100000]
10000
6←(RECLAIM]
collecting lists
7245, 92749 free cells, 0 pages left
92749
7←(GCGAG]
40
8←(MINFS 10000]
100000
9←SETUP]
T
10←(TEST]
(T 15821 4995)
11←(TEST]
(T 17498 6245)
12←(TEST]
(T 16569 5954)
13←(TEST]
(T 16707 5925)
14←(SETQ NOSWAPFLG T]
(NOSWAPFLG reset)
T
15←LOAD(IREWRITE.COM]
compiled on 5-Jul-82 12:11:29
FILE CREATED 5-Jul-82 12:11:22
(REWRITEBLOCK redefined)
(TEST redefined)
(SETUP redefined)
IREWRITECOMS
<CL.BOYER.LISPS>IREWRITE.COM.3
16←TEST]
(T 19546 8561)
17←TEST]
(T 17431 6601)
18←TEST]
(T 17192 6511)
19←TEST]
(T 18785 8161)
20←↑C
@POP
[PHOTO: Recording terminated Mon 5-Jul-82 12:29PM]
Interlisp bcompl no blocklib swap and noswap
[PHOTO: Recording initiated Mon 5-Jul-82 12:29PM]
LINK FROM CL.BOYER, TTY 17
Tops-20 Command Processor 4B(70)-1
End of <CL.BOYER>COMAND.CMD.1
@LISP.EXE.133
INTERLISP-10 27-NOV-79 ...
collecting lists
716, 10444 free cells
control-A is an interrupt and can't be an edit control-character
Hello, Bob.
2←LOAD(IREWRITE]
FILE CREATED 5-Jul-82 12:11:22
IREWRITECOMS
<CL.BOYER.LISPS>IREWRITE..3
3←IREWRITECOMS
((FNS * IREWRITEFNS) (PROP BLKLIBRARYDEF MEMBER SASSOC) (BLOCKS (REWRITEBLOCK
ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST APPLY-SUBST-LST FALSEP ONE-WAY-UNIFY
ONE-WAY-UNIFY1 ONE-WAY-UNIFY1-LST PTIME REWRITE REWRITE-ARGS REWRITE-WITH-LEMMAS
SETUP TAUTOLOGYP TAUTP TEST TRANS-OF-IMPLIES TRANS-OF-IMPLIES1 TRUEP (ENTRIES
TEST SETUP) (BLKLIBRARY EQUAL MEMBER GETPROP) (GLOBALVARS TEMP-TEMP UNIFY-SUBST)
)))
4←(BLOCKCOMPILE 'REWRITEBLOCK IREWRITEFNS '(TEST SETUP]
listing? STore and redefine
output file? No
(REWRITEBLOCK ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST APPLY-SUBST-LST FALSEP
ONE-WAY-UNIFY ONE-WAY-UNIFY1 ONE-WAY-UNIFY1-LST PTIME REWRITE REWRITE-ARGS
REWRITE-WITH-LEMMAS SETUP TAUTOLOGYP TAUTP TEST TRANS-OF-IMPLIES
TRANS-OF-IMPLIES1 TRUEP)
(REWRITEBLOCK (REWRITEBLOCK#0) (TEMP-TEMP UNIFY-SUBST))
collecting lists
6001, 10097 free cells
(TEST NIL NIL)
(TEST redefined)
(SETUP NIL NIL)
(SETUP redefined)
(TEST SETUP)
5←(SETUP]
T
6←(MINFS 100000]
10000
7←(RECLAIM]
collecting lists
9850, 90234 free cells, 0 pages left
90234
8←(MINFS 10000]
100000
9←(GCGAG]
40
10←NOSWAPFLG
NIL
11←(TEST]
(T 31978 6737)
12←(TEST]
(T 47072 6180)
13←(TEST]
LISP Running at 30547 Used 0:10:10.7 in 2:40:39, Load 3.06
(T 71046 6316)
14←(TEST]
LISP Running at 30525 Used 0:11:45.7 in 2:44:33, Load 2.85
(T 71222 7772)
15←(TEST]
(T 70026 6175)
16←(SETQ NOSWAPFLG T]
(NOSWAPFLG reset)
T
17←REDO BLOCKCOMPILE
listing? ST
output file? N
(REWRITEBLOCK ADD-LEMMA ADD-LEMMA-LST APPLY-SUBST APPLY-SUBST-LST FALSEP
ONE-WAY-UNIFY ONE-WAY-UNIFY1 ONE-WAY-UNIFY1-LST PTIME REWRITE REWRITE-ARGS
REWRITE-WITH-LEMMAS SETUP TAUTOLOGYP TAUTP TEST TRANS-OF-IMPLIES
TRANS-OF-IMPLIES1 TRUEP)
(REWRITEBLOCK (REWRITEBLOCK#0) (TEMP-TEMP UNIFY-SUBST))
(REWRITEBLOCK redefined)
(TEST NIL NIL)
(TEST redefined)
(SETUP NIL NIL)
(SETUP redefined)
(TEST SETUP)
18←(TEST]
(T 46501 7685)
19←TEST]
(T 45285 6068)
20←TEST]
(T 46995 7564)
21←TEST]
(T 46522 6180)
22←↑C
@POP
[PHOTO: Recording terminated Mon 5-Jul-82 12:51PM]
Maclisp
[PHOTO: Recording initiated Tue 29-Jun-82 12:26PM]
LINK FROM CL.BOYER, TTY 17
Tops-20 Command Processor 4A(67)-1
End of <CL.BOYER>COMAND.CMD.1
@<ATP.MURRAY>MACLSP
LISP 1983
Alloc? Y
# REGPDL = 4000
# SPECPDL = 2000
# FXPDL = 4000
# FLPDL = 1000
LIST = 40000 100000.
SYMBOL = 6000 $
*
(SETQ BASE (SETQ IBASE 10.))
10.
(FASLOAD MREWRITE)
40307.
(SETUP)
T
(TEST)
(T 20190000. 11905000.)
(TEST)
(T 13728000. 5236000.)
(TEST)
(T 13708000. 5398000.)
↑C
@POP
[PHOTO: Recording terminated Tue 29-Jun-82 12:29PM]
**********************************************************************
UCILISP
[PHOTO: Recording initiated Wed 30-Jun-82 12:16PM]
LINK FROM CL.BOYER, TTY 17
Tops-20 Command Processor 4B(70)-1
End of <CL.BOYER>COMAND.CMD.1
@
@ucilsp
UT/UCI LISP - 8/10/80
*(gcgag t)
NIL
*(gc)
3790 FREE STG, 1129 FULL WORDS AVAILABLE
NIL
*(expfs 100000.)
FREE STG EXHAUSTED
FULL WORD SPACE EXHAUSTED
101112 FREE STG, 1131 FULL WORDS AVAILABLE
*(loa≠≠≠≠Jdskin (rewrit.lap))
(ADD-LEMMA 32) (ADD-LEMMA-LST 10) (APPLY-SUBST 23) (APPLY-SUBST-LST 15)
(FALSEP 10) (ONE-WAY-UNIFY 2)
Binary Program Space exceeded
*(expbps 1000)
FREE STG EXHAUSTED
FULL WORD SPACE EXHAUSTED
101012 FREE STG, 1091 FULL WORDS AVAILABLE
*(dskin (rewrit.lap))
(ADD-LEMMA 32) (ADD-LEMMA-LST 10) (APPLY-SUBST 23) (APPLY-SUBST-LST 15)
(FALSEP 10) (ONE-WAY-UNIFY 2) (ONE-WAY-UNIFY1 38) (ONE-WAY-UNIFY1-LST 15)
(REWRITE 20) (REWRITE-ARGS 11) (REWRITE-WITH-LEMMAS 22) (SETUP 2) (TAUTOLOGYP
66) (TAUTP 4) (TEST 2) (TEST1 8) (TRANS-OF-IMPLIES 13) (TRANS-OF-IMPLIES1 31)
(TRUEP 10)
FILES-LOADED
*(setup)
T
*(test)
FREE STG EXHAUSTED
63969 FREE STG, 943 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
47018 FREE STG, 943 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
40438 FREE STG, 943 FULL WORDS AVAILABLE
50614 msec CPU (3738 msec GC), 67496 msec clock, 226465 conses
(T)
*(test)
FREE STG EXHAUSTED
94012 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
58810 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
47089 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
35091 FREE STG, 942 FULL WORDS AVAILABLE
51676 msec CPU (4605 msec GC), 72196 msec clock, 226467 conses
(T)
*(test)
FREE STG EXHAUSTED
91609 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
57005 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
45700 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
34252 FREE STG, 942 FULL WORDS AVAILABLE
52328 msec CPU (4809 msec GC), 70687 msec clock, 226467 conses
(T)
*(nouuo nil)
T
*(test)
FREE STG EXHAUSTED
89843 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
56841 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
45727 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
34117 FREE STG, 942 FULL WORDS AVAILABLE
14099 msec CPU (4711 msec GC), 20077 msec clock, 226467 conses
(T)
*(test)
FREE STG EXHAUSTED
89806 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
56830 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
45727 FREE STG, 942 FULL WORDS AVAILABLE
FREE STG EXHAUSTED
34117 FREE STG, 942 FULL WORDS AVAILABLE
13827 msec CPU (4712 msec GC), 19857 msec clock, 226467 conses
(T)
*
@pop
[PHOTO: Recording terminated Wed 30-Jun-82 12:24PM]
Interlisp (Dolphin and Dorado)
Date: 8 Jul 1982 18:56 PDT
From: JonL at PARC-MAXC
Reply-To: JonL at PARC-MAXC
To: NOVAK at SUMEX-AIM
cc: CL.BOYER, Masinter at PARC-MAXC, LispCore↑ at PARC-MAXC
Re: The Boyer-Moore-Novak Benchmarkings
Gordon, I'll have to apologize for waiting so long to get you the results
of the timing comparisons between your machine and the various
configurations at PARC. I was "laid-low" last Saturday with either a
summer flu, or a severe allergic reaction (hay fever), and couldn't get
the results summarized until yesterday.
I have six areas that I want to summarize in this note:
Translation Inadequacy due to the FreeVars Trip-Up
"Ineffable" Factors Tending to make timing runs Un-Reproducible
PUP Activity -- Ephemeral as well as Ineffable
What the Faster Clock on buys
What DISPLAYDOWN buys
What you can Expect for Dolphin Speed Increases Soon
Briefly, the "FreeVars Trip-Up" and the DISPLAYDOWN account
for most of the sluggishness of the timings you made, but also there's
one "ineffable" which might be sabotaging you.
Below these sections, I've tried to display my data in good scientific
fashion; you'll note that I give a "First run" time and a "Mode run" time.
What this means is the "First run" must absorb all the "ineffable" costs of
swapping in the necessary code and data parts, and of initially-building
the List-space pages that will be used and re-used on subsequent runs.
Also included are one set of timings from a Dorado, just for comparison.
Generally, my comparisons will be of "speed" rather than "time". Thus
if one trial takes 40 secs, and another takes 50 secs, then the first one
runs 25% faster (the other way of saying it would be that the first one
takes 20% less time). The rationale is this: the first one "computes"
.025 MegaFrumbles per second, while the second one only computes
.020 MegaFrumbles per second; hence the speed of the first one is
(.025-.020)/.020 = 25% faster than the speed of the second one.
Translation Inadequacy due to the FreeVars Trip-Up
Actually, it's just as well that I waited until today to report to you,
since the **major factor** in the timings compared so far is the old
"FreeVars Trip-Up", and anyway Boyer's latest modification is more
appropriate for benchmarking, period. I have quite a few interesting
timings to report (and a few remaining mysteries regarding your
machine), but indeed the major discrepancy between your timings
and mine was that the version of IREWRITE we had at Parc is the one
that Larry had "diddled" as per his earlier note.
On your machine, I saw a 50% speedup due to better treatment of the
free variable TEMP-TEMP. (My runs of your original version of
IREWRITE compared with Larry's "diddled" version).
On several machines here, I compared Larry's "diddled" version with
Boyer's new version, and observed about a 9% speed-up of the latter
over the former. Converting TEMP-TEMP from a local variable to a
GLOBALVAR should cause a slowdown in the 1% range (a GLOBALVAR
usage may take time for a GC-hash-table operation, but a LOCALVAR
usage takes time only for pushing/popping the stack) but Boyer changed
several other bottlenecks and the speed increases therefrom more than
compensated for the loss of the local variable (SASSOC ==> FASSOC,
and the placement of important properties at the beginning of the proplist ?)
In any case, this benchmark exhibits a factor of two improvement by
removing what I'm calling the "FreeVars Trip-Up".
This point can't be overstressed: that Interlisp-D is a deep-bound
implementation, whereas MacLisp and current Interlisp-10 are shallow-
bound (Interlisp-10 was first deep-bound, then later shallow-bound),
and that the questionable practice of using free variables for local
temporaries costs little when they are shallow-bound, but could
cost arbitrarily large when deep-bound. I say, "questionable" since a
program with such temporaries is semantically the same regardless of
whether they are GLOBAL, SPECIAL, or local; furthermore, the
general direction of "structured programming" is to avoid free variables
at all costs, and to bind temporaries as syntactically "low" as possible.
The *default* declaration for variables in Interlisp is SPECVARS, for
consistency with the way the interpreter is written, and thus the default
compilation of a free variable will cause a stack scan (slow) rather than a
reference to the global value cell (fast). So one does have to take *some*
action to override the default case when transporting such a program.
A recent Symbolics advertising flyer makes a "comparison" of an Interlisp
program running on the Dolphin and on the LM-2. It wasn't so much
a comparison between Interlisp-D/Dolphin with ZetaLisp/CADR as a
documentation of someone's failure to add the appropriate GLOBALVARS
delcarations. I heard (admittedly, hearsay) that the ISI guy whose program
was under test made the additional declaration himself, and the Dolphin
performance "improved by 67%". [One also wonders how the "comparison"
would have fared had the LISPMachine garbage collector been operable;
a large percentage of the Dolphin time was spent in GC, which helps keep
the working-set small, and also allows you to continue running *after*
the benchmark has finished running.]
"Ineffable" Factors Tending to make timing runs Un-Reproducible
As Larry's note indicated, there is a hidden problem with swap time in
the Interlisp-D of today -- an "ineffable" amount of it is being charged
to CPU time rather than the reported Swap time. The data below seem
to indicate anywhere from 5% to 20% of reported CPU time is really swap
time, when there is indeed swapping going on.
You're quite right, however, that swapping-time is a small factor in this
benchmark; although there consistently seemed to be more of it on your
machine than mine (about 8%, depending on method of interpretation of
the "ineffable" considerations herein mentioned). That's mystery number 1,
since both your machine and mine have the same amount of real memory,
namely about 1.15 Megabyte. The proper setting of RECLAIMMIN keeps
both our Dolphins from "going over the knee" on this benchmark, although
a large setting for my Dolphin caused the CPU time to go up by 50%
and the Swap time to go up from essentially 0 to almost 600 seconds. A
Dorado, with 2 Megabytes and a faster swapping-disk, didn't "go over the
knee" even with the extreme high setting of RECLAIMMIN.
During the first run of TEST, additional pages are added to LIST space,
and the cost of doing this is difficult to estimate accurately in the current
setup. The STATS I ran on the Dorado showed nearly 20% of the
total first-run time given to this activity, but this is inflated by the
fact that the run had to be terminated abnormally (ran out of DSK space
for keeping statistics); this "ineffable" time would concentrate in the
early part of the run. But a 5%-10% slowdown due to this facter seems
indicated in general (my "educated guess" from mulling over the data).
There is a certain oddity about the reference-count GC scheme in that
a call to RECLAIM may not necessarily recover all reclaimable space.
Without going into the details of this oddity, I merely observed that
between TEST runs, it was necessary to do several iterations of
(RECLAIM) before the time spent therein settled down to a typical low
value [indicating that most if not all reclaimables were in fact reclaimed].
This is why I've indicated a "mode" run -- namely the timings that are
most often seen after the initial swap-in, initial swell-up of LIST space,
and "cleanness" of the reclaimable space are accounted for. But I must
confess, that I hadn't discovered all of these things initially, so there is
a little uncertainty about the "mode" timings done on July 2.
PUP Activity -- Ephemeral as well as Ineffable
Mystery number 2 is why the "diddled" TEST run on your machine has
a "mode" of 210 CPU seconds as opposed to about 143 CPU seconds on a
comparably-clocked machine here running the current CONBRIO release.
(This was my measurement for the "diddled" version -- you reported 278
for the original version and I recorded 299. for the original version -- but
the "diddled" version is *exactly* the same file I had at PARC, in the same
release of Lisp).
It's almost as if you had some large overhead activity going on all the time,
such as snarfing up random PUPs and throwing them away. Pup activity
could be a highly-variable thing, and could account for large timing
differences between say Friday afternoon and Thursday morning.
Unfortunately, its also something that is not easily controlled by a user
doing timings, since it depends the PUP activity of others users of the
same ethernet. Currently, time spent in Interlisp-D "dropping" non-
intended PUPs is not visible in the timings statistics (it would merely
bloat reported CPU time). PUP activity could be monitored by another
Dolphin running EtherWatch while you are running timings on yours.
[A simple way of temporarily turning off PUP activity might help
filter out this as a source of variability; are you interested in trying?]
What the Faster Clock on buys
My Dolphin is indeed faster than many others, because it has a clock
crystal running at 44.5 MegaHertz. The Dolphin was originally intended
to run at 50MHz, but due to a larger-than-expected variability in the
components (chips, etc) the production models are currently pegged at
40MHz. Machines with a 44.5MHz clock have a speed increase of about 12% to
16%. The reason why this isn't merely 10% is that there is a "buffering"
action of the constant-time overhead required for maintaining the display
and sampling the keyboard; thus a faster machine spends proportionately
less of its time in these constant overhead tasks. Of course, 50MHz clocks
would result in even more performance improvement.
What DISPLAYDOWN buys
I thought that you had run with DISPLAYDOWN during the compute-
bound TEST; so I ran this way on my runs, except for those intended
to gather data which would correlate the effect of DISPLAYDOWN.
It makes sense to do so on *compute-bound* tasks, since an average
speed increase of 41% to 45% is thereby obtained.
As expected, the display off means more to CPU time on a 40MHz
machine than to that on a 44.5MHz one -- 43% as opposed to only 36%.
GC timings are so variable that I factored them out for these percentages.
[I don't think one would see anything like this gain if the keyboard
sampling mentioned above were similarly shut off; Dorado STATS point
to maybe 6% possible, but even this overhead cost may go down as more
software is developed. As a side comment, display maintenance is not
a significant factor in the Dorado or in the DandeLion.]
What you can Expect for Dolphin Speed Increases Soon
The WIND version of the software will likely be released later this
year, and the data herein indicate a minimum of about 10% overall
increase in speed; other preliminary measures suggest a speed-up of
15% to 20%. Faster hardware may be in the works, but I'm not the one
to comment in any offical way about this. Maybe when we get some
more benchmarks (such as Dick Gabriel is pushing for), we'll do them
on the latest Dolphins.
Just for the record, I'd like to include some timings given me by Larry,
which were done on the Dolphin of one year ago (the "diddled" version
of the problem):
Swap time = 30secs
GC time = 175secs
CPU time = 750secs
Elapsed = 950secs
So today's "vanilla" times are 5.6 times faster than last years, and on my
44.5Mhz machine running WIND I see a speed-up of a factor of 7.
A factor of 7!
Bill van Melle suggests that these speed-ups are due mainly to improvements
in function call and CONS, and that's precisely what the Boyer-Moore
IREWRITE benchmark tests. I really don't think anything quite that dramatic is
on the horizon for the *overall* Dolphin performance, but *selected areas*
which we have targeted for more devolpment could show stellar improvement.
(such as putting floating-point into microcode).
Hope to see you at AAAI.
_________________________________________________
The Raw Data
Machines: GSN (Gordon Novak's), JONL (mine), SYBAL (John Sybalsky's)
[GSN and SYBAL have 40MHz, JONL has 44.5MHz]
Finisterra (the only Dorado included)
Program: OB (Old Boyer code, without declarations)
NB (New Boyer code, with GLOBALVARS for free temps)
Diddled (Larry Masinter's reworking using local lambda
binding for temporaries)
Version: CB (current release CONBRIO), WD (WIND system)
Options: DD (display "down", or off), DU (display "up")
1st (first run), nth ("mode", or most frequently observed after first)
All measurements in seconds. Timings on SYBAL,NB,CB,DD were also
reproduced quite closely on Larry Masinter's machine, and on Stu Card's.
Display Up vs. Display Down times
-----------------------------------------------------------------
Swap 3.6 GSN | Swap 3.0 GSN July 2
GC 66.4 OB | GC 49. OB
CPU 415. CB,DU,nth | CPU 299. CB,DD,nth
Swap 33.1 GSN | Swap 5.7 GSN July 2
GC 70.0 diddled | GC 50.9 diddled
CPU 305. CB,DU,1st | CPU 210. CB,DD,nth
Swap 0.5 JONL | Swap - JONL July 2
GC 60. diddled | GC 30.2 diddled
CPU 158. WD,DU,nth | CPU 116. WD,DD,nth
Swap - SYBAL | Swap - SYBAL July 7
GC 56. diddled | GC 39.6 diddled
CPU 204. CB,DU,nth | CPU 143. CB,DD,nth
First run vs. nth ("mode") run; Display Down
-----------------------------------------------------------------
Swap 2. JONL | Swap - JONL July 7
GC 26.7 NB | GC 31.6 NB
CPU 142. CB,DD,1st | CPU 117. CB,DD,nth
Swap .2 JONL | Swap - JONL July 7
GC 24.9 NB | GC 28.2 NB
CPU 119. WD,DD,1st | CPU 107. WD,DD,nth
Swap 9.8 SYBAL | Swap - SYBAL July 7
GC 31. NB | GC 35. NB
CPU 140. CB,DD,1st | CPU 132. CB,DD,nth
Swap .14 SYBAL | Swap - SYBAL July 7
GC 20.6 NB | GC 31.7 NB
CPU 133. WD,DD,1st | CPU 119. WD,DD,nth
Swap .1 SYBAL | Swap - SYBAL July 7
GC 33.2 diddled | GC 35. diddled
CPU 150. WD,DD,1st | CPU 130. WD,DD,nth
Dorado time
-----------------------------------------------------------------
Swap ? Finisterra | Swap - Finisterra July 2
GC 11.4 diddled | GC 17. diddled
CPU 25.6 WD,1st | CPU 22.7 WD,nth
The STATS file mentioned for Dorado analysis is on the PHYLUM
file server at PARC, file <JONL>TEST.PRINTOUT. Since it's a
lengthy account of an incomplete run, I didn't reproduce it here.
Mail-from: ARPANET site SU-SCORE rcvd at 8-Jul-82 1245-CDT
Date: 8 Jul 1982 1043-PDT
From: Gordon Novak <CSD.NOVAK at SU-SCORE>
To: Masinter at PARC-MAXC, CL.BOYER at UTEXAS-20
cc: JonL at PARC-MAXC
In-Reply-To: Your message of 7-Jul-82 1812-PDT
Date: Thursday, 8 July 1982 12:43-CDT
From: Gordon Novak <CSD.NOVAK at SU-SCORE>
To: Masinter at PARC-MAXC, CL.BOYER
cc: JonL at PARC-MAXC
I reran the test as Larry did, with similar results (included below).
My problem was that I used TCOMPL instead of BCOMPL. I recall being
told by someone that the Dolphin didn't block-compile like Interlisp-10,
so that BCOMPL and TCOMPL did the same thing. Obviously that isn't true;
I should have been more careful. I apologize for raising a ruckus over
a silly mistake; at least I'm glad that the results will be fair to the
Dolphin crowd.
DISPLAYDOWN, as used in Larry's test, totally turns off the display for
the duration. I haven't used it myself, but I understand that it can
get one into funny problemsif e.g. there are errors in the execution
of the program with the display off; I don't know if most users would
find it acceptable to run in this mode.
NIL
Mail-from: ARPANET site PARC-MAXC rcvd at 13-Jul-82 0217-CDT
From: JonL at PARC-MAXC
To: CL.BOYER
cc: JonL at PARC-MAXC
Re: Timings Table for IREWRITE benchmark
Yes, the SYBAL,NB,CB,DD is an appropriate time for the current "vanilla"
Dolphin; but the Dorado timing I reported in the previous note can't be
strictly compared with the others since it was running the "diddled" test
rather than the NewBoyer (NB) test, and was in the WIND release rather
than CONBRIO. [As it happens, the "diddling" had somewhat of a misfeature
in it, which is why I mentioned that NB is a much better benchmark anyway].
Dorado Frontenac, NewBoyer.benchmark(NB),systemCONBRIO(CB)
DisplayDown (DD) times for "mode" (nth) run:
GC = 10.9
CPU = 17.6
DisplayUp (DU) times for "mode" (nth) run:
GC = 11.8
CPU = 19.2
DisplayDown (DD) times for "FirstRun" (1st) run:
Swap = .027
GC = 10.5
CPU = 17.4
It's not clear to me why the "FirstRun" time was faster in these trials -- chalk
it up to "noise", or maybe to the benefits of larger-memory/faster-disk?
∨
←LOAD(IREWRITE.DCOM)
compiled on 8-JUL-82 09:54:44
FILE CREATED 5-Jul-82 12:52:49
IREWRITECOMS
{DSK}IREWRITE.DCOM;2
←(DISPLAYDOWN (TIMEALL (SETUP)))
Elapsed Time = .755 seconds
SWAP time = .582 seconds
CPU Time = .173 seconds
PAGEFAULTS = 12
LISTP
224
T
←(DISPLAYDOWN '(TIMEALL (TEST)))
Elapsed Time = 175.0 seconds
SWAP time = 6.63 seconds
GC time = 31.5 seconds
CPU Time = 137.0 seconds
PAGEFAULTS = 610
SWAPWRITES = 157
FIXP LISTP
311 226469
(T 168388 31471)
←REDO
Elapsed Time = 183.0 seconds
SWAP time = .494 seconds
GC time = 48.7 seconds
CPU Time = 134.0 seconds
PAGEFAULTS = 21
FIXP LISTP
375 226469
(T 182913 48703)
←REDO
Elapsed Time = 188.0 seconds
SWAP time = .078 seconds
GC time = 52.3 seconds
CPU Time = 136.0 seconds
PAGEFAULTS = 2
FIXP LISTP
419 226469
(T 188209 52257)
←REDO
Elapsed Time = 188.0 seconds
SWAP time = .015 seconds
GC time = 51.2 seconds
CPU Time = 137.0 seconds
PAGEFAULTS = 14
FIXP LISTP
401 226469
(T 187906 51188)
←TIMEALL((TEST))
Elapsed Time = 271.0 seconds
SWAP time = .059 seconds
GC time = 75.3 seconds
CPU Time = 195.0 seconds
PAGEFAULTS = 1
FIXP LISTP
420 226469
(T 270715 75315)
←TIMEALL((TEST))
Elapsed Time = 267.0 seconds
SWAP time = .006 seconds
GC time = 73.2 seconds
CPU Time = 194.0 seconds
PAGEFAULTS = 6
FIXP LISTP
402 226469
(T 267145 73153)
←TIMEALL((TEST))
Elapsed Time = 266.0 seconds
GC time = 72.6 seconds
CPU Time = 194.0 seconds
FIXP LISTP
402 226469
(T 266215 72623)
←DRIBBLE]
∨
The INTERLISP VAX test
Mail-from: ARPANET site USC-ISIB rcvd at 23-Jul-82 1108-CDT
Date: 23 Jul 1982 0907-PDT
Sender: RBATES at USC-ISIB
Subject: Re: lisp comparison.
From: Raymond Bates <RBATES at ISIB>
To: CL.BOYER at UTEXAS-20
Cc: CMP.GOOD at UTEXAS-20, ddyer at USC-ISIB, lynch at USC-ISIB,
Cc: Novak at SUMEX-AIM
Message-ID: <[USC-ISIB]23-Jul-82 09:07:07.RBATES>
In-Reply-To: Your message of Thursday, 22 July 1982 13:12-CDT
*** EOOH ***
Date: Friday, 23 July 1982 11:07-CDT
From: Raymond Bates <RBATES at ISIB>
Sender: RBATES at USC-ISIB
To: CL.BOYER
cc: CMP.GOOD, ddyer at USC-ISIB, lynch at USC-ISIB, Novak at SUMEX-AIM
Re: lisp comparison.
Here is the DRIBBLE file of a long run:
NIL
4←(GCGAG NIL]
40
5←LOAD(IREWRITE.v]
compiled on 22-JUL-82 09:22:17
File Created: 5-Jul-82 12:52:49
% warning! this file possibly incompatible!
Compiled by version 3.0 but current version is 2.1
IREWRITECOMS
/lisp/rbates/lisp/IREWRITE.v;2
6←(SETUP]
T
7←(FOR I FROM 1 TO 20 DO (PRINT (TEST ]
(T 76048 0)
(T 76464 0)
(T 76496 0)
(T 76272 0)
(T 89072 4784)
(T 80992 0)
(T 81840 0)
(T 81600 0)
(T 90512 4752)
(T 81904 0)
(T 82032 0)
(T 81248 0)
(T 90512 5456)
(T 80768 0)
(T 80800 0)
(T 80656 0)
(T 91424 5456)
(T 82112 0)
(T 82384 0)
(T 82432 0)
NIL
8←(DRIBBLE]
You many wonder why the cpu time has an extra 10 seconds each
time the system does a gc. The reason is that the system has to
re-hash all the hash array after the gc and time is being charge
to the computation time and not gc time (we will fix that). This
test was done on our 780. Any thing else you would like to see
or known?
/Ray
∨
;;; SAIL
(fasload boyer)
(timit)
Timing performed on Wednesday 09/15/82 at 10:50:58.
Cpu Time = 7.635
Elapsed Time = 726.53333
Wholine Time = 241.866667
GC Time = 120.472
Load Average Before = 6.1742424
Load Average After = 2.85985446
Average Load Average = 4.5170484
NIL
Timing performed on Wednesday 09/15/82 at 11:03:27.
Cpu Time = 7.49
Elapsed Time = 65.0
Wholine Time = 36.4166665
GC Time = 12.669
Load Average Before = 2.54934967
Load Average After = 2.2733817
Average Load Average = 2.4113657
NIL
Timing performed on Wednesday 09/15/82 at 11:04:44.
Cpu Time = 7.509
Elapsed Time = 59.3166666
Wholine Time = 32.866667
GC Time = 11.513
Load Average Before = 2.17366004
Load Average After = 2.06962526
Average Load Average = 2.12164265
NIL
;;; SAIL (FIXSW T)
(fasload boyer)
(timit)
Timing performed on Wednesday 09/15/82 at 11:06:16.
Cpu Time = 7.629
Elapsed Time = 1076.21666
Wholine Time = 229.366667
GC Time = 120.4
Load Average Before = 1.81269705
Load Average After = 8.4301555
Average Load Average = 5.1214263
NIL
Timing performed on Wednesday 09/15/82 at 11:24:17.
Cpu Time = 7.494
Elapsed Time = 86.016666
Wholine Time = 36.733333
GC Time = 12.692
Load Average Before = 8.2354884
Load Average After = 5.64889336
Average Load Average = 6.9421909
NIL
Timing performed on Wednesday 09/15/82 at 11:25:45.
Cpu Time = 7.484
Elapsed Time = 82.3
Wholine Time = 33.983333
GC Time = 11.519
Load Average Before = 5.58177483
Load Average After = 4.12152493
Average Load Average = 4.8516499
NIL
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 SAIL
C00004 ENDMK
C⊗;
;;; SAIL
(FASLOAD DESTRU)
(TIMIT)
Timing performed on Thursday 09/23/82 at 14:51:40.
Cpu Time = 2.472
Elapsed Time = 28.2666667
Wholine Time = 14.3
GC Time = 5.795
Load Average Before = 1.25672555
Load Average After = 1.73288608
Average Load Average = 1.49480581
NIL
Timing performed on Thursday 09/23/82 at 14:52:11.
Cpu Time = 2.47
Elapsed Time = 36.883333
Wholine Time = 12.9333333
GC Time = 5.387
Load Average Before = 1.74602473
Load Average After = 1.88764822
Average Load Average = 1.81683648
NIL
Timing performed on Thursday 09/23/82 at 14:52:51.
Cpu Time = 2.47
Elapsed Time = 36.0333333
Wholine Time = 13.1666666
GC Time = 5.401
Load Average Before = 1.899001
Load Average After = 2.04023933
Average Load Average = 1.96962017
NIL
COMMENT ⊗ VALID 00003 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 InterLisp of Dolphin, Dorado
C00004 00003 SAIL
C00006 ENDMK
C⊗;
;;; InterLisp of Dolphin, Dorado
∂09-Oct-82 0413 JonL at PARC-MAXC Order of magnitude on PUZZLE
Date: 9 Oct 1982 04:13 PDT
From: JonL at PARC-MAXC
Subject: Order of magnitude on PUZZLE
To: RPG@SU-AI
cc: LispCore↑, Raim.EOS, Pahlavan.EOS
I've got my little "CommonLisp" array package coded up now (it's on
the ADDARITH file), which uses "margin arrays" for multi-dimension
arrays. Using that, rather than ELT and SETA, and with DisplayDown,
I ran the Baskett benchmark PUZZLE on the Dolphin you used yesterday,
and got a time of 71.4 seconds.
This compares with the DisplayUp ELT/SETA time you got of 616. seconds.
Didn't you say that the LM-2 time was around 91 seconds?
P.S. -- Dorado time was about 11.4 seconds
P.P.S. -- This ""CommonLisp" array package needs a little more debugging,
but some version of the "fast" AREF might well be useful to others,
just as the "fast" ELT is used in Interlisp-10.
;;; SAIL
(fasload puzzl1)
(timit)
Timing performed on Saturday 10/09/82 at 09:51:51.
success in 2005 trials
Cpu (- GC) Time = 9.882
Elapsed Time = 20.2333333
Wholine Time = 15.7166667
GC Time = 0.427
Load Average Before = 0.373874426
Load Average After = 0.51568842
Average Load Average = 0.444781423
NIL
Timing performed on Saturday 10/09/82 at 09:52:28.
success in 2005 trials
Cpu (- GC) Time = 9.854
Elapsed Time = 15.8166667
Wholine Time = 14.2166667
GC Time = 0.422
Load Average Before = 0.488048077
Load Average After = 0.553620696
Average Load Average = 0.52083439
NIL
Timing performed on Saturday 10/09/82 at 09:52:44.
success in 2005 trials
Cpu (- GC) Time = 9.86
Elapsed Time = 16.65
Wholine Time = 14.6
GC Time = 0.423
Load Average Before = 0.55559218
Load Average After = 0.61845243
Average Load Average = 0.587022305
NIL
COMMENT ⊗ VALID 00012 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 (fasload nrevers)
C00005 00003 (fasload nrevers)
C00008 00004 (fasload nrevers)
C00011 00005 (fasload nrevers)
C00013 00006 (fasload nrevers)
C00017 00007 (fasload nrevers)
C00021 00008 (fasload nrevers)
C00025 00009 (fasload nrevers)
C00026 00010 SAIL (MODEL B)
C00032 00011 Why is Kreverse faster than Greverse in the 0-7(10000) case?
C00040 00012 (fasload nreverse)
C00043 ENDMK
C⊗;
(fasload nrevers)
(defun better (x y)
(//$ (-$ x y) x))
(gtimits)
Timing performed on Friday 01/21/83 at 18:16:20.
Cpu (- GC) Time = 5.03
Elapsed Time = 12.4166666
Wholine Time = 6.96666664
GC Time = 0.0
Load Average Before = 0.32562709
Load Average After = 0.458365798
Average Load Average = 0.391996443
NIL
(xtimits)
Timing performed on Friday 01/21/83 at 17:28:38.
Cpu (- GC) Time = 4.79
Elapsed Time = 21.6
Wholine Time = 7.23333335
GC Time = 0.0
Load Average Before = 2.44889772
Load Average After = 2.61320937
Average Load Average = 2.53105354
NIL
XREVERSE IS 4.77% BETTER THAN GREVERSE
(ntimits)
Timing performed on Friday 01/21/83 at 17:45:14.
Cpu (- GC) Time = 2.434
Elapsed Time = 22.5166667
Wholine Time = 3.86666667
GC Time = 0.0
Load Average Before = 2.42375052
Load Average After = 3.09093595
Average Load Average = 2.75734323
NIL
NREVERSE IS 49.18% BETTER THAN XREVERSE
;(gtimitl)
Timing performed on Friday 01/21/83 at 18:18:23.
Cpu (- GC) Time = 43.978
Elapsed Time = 80.0
Wholine Time = 65.0
GC Time = 0.0
Load Average Before = 0.78599167
Load Average After = 1.02788734
Average Load Average = 0.90693951
NIL
(xtimitl)
Timing performed on Friday 01/21/83 at 17:32:41.
Cpu (- GC) Time = 47.279
Elapsed Time = 190.466667
Wholine Time = 77.533334
GC Time = 0.0
Load Average Before = 1.96534216
Load Average After = 2.55297685
Average Load Average = 2.2591595
NIL
GREVERSE IS 6.98% BETTER THAN XREVERSE
(ntimitl)
Timing performed on Friday 01/21/83 at 17:45:44.
Cpu (- GC) Time = 21.142
Elapsed Time = 76.066667
Wholine Time = 35.1
GC Time = 0.0
Load Average Before = 3.02057815
Load Average After = 2.91055357
Average Load Average = 2.96556586
NIL
NREVERSE IS 51.93% BETTER THAN GREVERSE
(fasload nrevers)
(xtimits)
Timing performed on Thursday 01/27/83 at 14:12:29.
Cpu (- GC) Time = 5.453
Elapsed Time = 16.8166666
Wholine Time = 8.2666667
GC Time = 0.0
Load Average Before = 1.16764712
Load Average After = 1.35011363
Average Load Average = 1.25888038
NIL
(gtimits)
Timing performed on Thursday 01/27/83 at 14:12:51.
Cpu (- GC) Time = 5.724
Elapsed Time = 22.3333333
Wholine Time = 8.0333333
GC Time = 0.0
Load Average Before = 1.38667965
Load Average After = 1.67263377
Average Load Average = 1.52965671
NIL
Statistics
Meter for: GREVERSE
(meter:report)
Entries = 100000
Special Exit1 = 10000
Special Exit2 = 5000
Special Exit3 = 5000
Exit1 = 30000
Exit2 = 25000
Exit3 = 25000
Meter for: XREVERSE
Entries = 100000
Exit1 = 35000
Exit2 = 35000
Exit3 = 30000
T
(xtimitl)
Timing performed on Thursday 01/27/83 at 14:27:52.
Cpu (- GC) Time = 47.951
Elapsed Time = 344.766666
Wholine Time = 92.183333
GC Time = 0.0
Load Average Before = 1.95733905
Load Average After = 4.20302606
Average Load Average = 3.08018255
NIL
(gtimitl)
Timing performed on Thursday 01/27/83 at 14:34:05.
Cpu (- GC) Time = 44.868
Elapsed Time = 189.316668
Wholine Time = 76.1
GC Time = 0.0
Load Average Before = 4.2228086
Load Average After = 3.07352614
Average Load Average = 3.64816737
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 50000
Special Exit1 = 200
Special Exit2 = 100
Special Exit3 = 100
Exit1 = 16600
Exit2 = 16500
Exit3 = 16500
Meter for: XREVERSE
Entries = 50000
Exit1 = 16700
Exit2 = 16700
Exit3 = 16600
T
(fasload nrevers)
(fasload meter)
(greverse-init)(xreverse-init)
(xtimits)
Timing performed on Thursday 01/27/83 at 16:11:01.
Cpu (- GC) Time = 8.27
Elapsed Time = 25.2666667
Wholine Time = 12.8666667
GC Time = 0.0
Load Average Before = 2.087772
Load Average After = 2.15831673
Average Load Average = 2.12304437
NIL
(gtimits)
Timing performed on Thursday 01/27/83 at 16:11:50.
Cpu (- GC) Time = 8.165
Elapsed Time = 23.5833333
Wholine Time = 12.75
GC Time = 0.0
Load Average Before = 1.91675103
Load Average After = 2.0045544
Average Load Average = 1.96065271
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 100000
RPLACAs = 180000
RPLACDs = 840000
Meter for: XREVERSE
Entries = 100000
RPLACDs = 950000
T
GREVERSE-ARRAY
XREVERSE-ARRAY
(xtimitl)
Timing performed on Thursday 01/27/83 at 16:13:13.
Cpu (- GC) Time = 88.429
Elapsed Time = 298.35
Wholine Time = 142.2
GC Time = 0.0
Load Average Before = 1.7085036
Load Average After = 2.5986457
Average Load Average = 2.15357465
NIL
(gtimitl)
Timing performed on Thursday 01/27/83 at 16:18:54.
Cpu (- GC) Time = 85.044
Elapsed Time = 197.65
Wholine Time = 130.983334
GC Time = 0.0
Load Average Before = 2.44514573
Load Average After = 1.86368799
Average Load Average = 2.15441686
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 50000
RPLACAs = 99600
RPLACDs = 12424800
Meter for: XREVERSE
Entries = 50000
RPLACDs = 12475000
T
(fasload nrevers)
(fasload meter)
(xtimitl1)
Timing performed on Thursday 01/27/83 at 16:52:28.
Cpu (- GC) Time = 89.725
Elapsed Time = 323.733334
Wholine Time = 143.15
GC Time = 0.0
Load Average Before = 1.36123526
Load Average After = 2.66708148
Average Load Average = 2.01415837
NIL
(gtimitl1)
Timing performed on Thursday 01/27/83 at 16:58:07.
Cpu (- GC) Time = 86.761
Elapsed Time = 246.266666
Wholine Time = 144.166666
GC Time = 0.0
Load Average Before = 2.4922185
Load Average After = 2.20709407
Average Load Average = 2.34965628
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 50000
RPLACAs = 100000
RPLACDs = 12625000
Meter for: XREVERSE
Entries = 50000
RPLACDs = 12675000
T
(fasload nrevers)
(fasload meter)
(xtimits)
Timing performed on Thursday 01/27/83 at 17:49:47.
Cpu (- GC) Time = 12.572
Elapsed Time = 44.366667
Wholine Time = 18.3
GC Time = 0.0
Load Average Before = 0.7300719
Load Average After = 1.36674821
Average Load Average = 1.04841006
NIL
(gtimits)
Timing performed on Thursday 01/27/83 at 17:51:00.
Cpu (- GC) Time = 11.347
Elapsed Time = 22.9
Wholine Time = 15.9333333
GC Time = 0.0
Load Average Before = 1.22334313
Load Average After = 1.30853271
Average Load Average = 1.26593792
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 100000
NULLs = 890000
RPLACAs = 180000
RPLACDs = 840000
GOs = 175000
Meter for: XREVERSE
Entries = 100000
NULLs = 1050000
RPLACDs = 950000
GOs = 285000
T
(xtimitl)
Timing performed on Thursday 01/27/83 at 17:52:12.
Cpu (- GC) Time = 142.512
Elapsed Time = 309.05
Wholine Time = 210.416666
GC Time = 0.0
Load Average Before = 1.00957465
Load Average After = 1.60779774
Average Load Average = 1.3086862
NIL
(gtimitl)
Timing performed on Thursday 01/27/83 at 17:57:41.
Cpu (- GC) Time = 139.893
Elapsed Time = 306.833332
Wholine Time = 209.566668
GC Time = 0.0
Load Average Before = 1.43141723
Load Average After = 1.8702892
Average Load Average = 1.65085322
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 150000
NULLs = 13315800
RPLACAs = 279600
RPLACDs = 13264800
GOs = 4250500
Meter for: XREVERSE
Entries = 150000
NULLs = 13575000
RPLACDs = 13425000
GOs = 4426700
T
NULLs
type 13575000-13315800
13575000-13315800 = 259200
RPLACs
type 13425000-(13264800+279600)
13425000-(13264800+279600) = -119400
GOs
type 4426700-4250500
4426700-4250500 = 176200
XREVERSE does this many more operations than GREVERSE
type 259200+176200-119400
259200+176200-119400 = 316000
(greverse-init)(xreverse-init)
(gtimitl)
Timing performed on Thursday 01/27/83 at 18:08:20.
Cpu (- GC) Time = 139.837
Elapsed Time = 333.15
Wholine Time = 208.1
GC Time = 0.0
Load Average Before = 0.45505178
Load Average After = 1.75526619
Average Load Average = 1.10515898
NIL
(fasload nrevers)
(fasload meter)
(xtimits)
Timing performed on Thursday 01/27/83 at 18:51:58.
Cpu (- GC) Time = 19.132
Elapsed Time = 110.566667
Wholine Time = 27.2166667
GC Time = 0.0
Load Average Before = 3.37192142
Load Average After = 3.84085488
Average Load Average = 3.60638815
NIL
(gtimits)
Timing performed on Thursday 01/27/83 at 18:54:02.
Cpu (- GC) Time = 19.735
Elapsed Time = 47.4166665
Wholine Time = 28.3666666
GC Time = 0.0
Load Average Before = 3.62646997
Load Average After = 3.13842237
Average Load Average = 3.38244617
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 100000
NULLs = 1050000
SETQs = 1265000
CDRs = 1030000
RPLACAs = 180000
CARs = 180000
PROGs = 80000
RPLACDs = 840000
GOs = 175000
Meter for: XREVERSE
Entries = 100000
PROGs = 100000
NULLs = 1050000
CDRs = 950000
SETQs = 950000
RPLACDs = 950000
GOs = 285000
T
(greverse-init)(xreverse-init)
GREVERSE-ARRAY
XREVERSE-ARRAY
(gtimitl)
Timing performed on Thursday 01/27/83 at 20:04:43.
Cpu (- GC) Time = 222.446
Elapsed Time = 398.066666
Wholine Time = 314.9
GC Time = 0.0
Load Average Before = 0.41551113
Load Average After = 1.29725814
Average Load Average = 0.856384635
NIL
(xtimitl)
Timing performed on Thursday 01/27/83 at 20:12:09.
Cpu (- GC) Time = 224.331
Elapsed Time = 399.166668
Wholine Time = 323.216667
GC Time = 0.0
Load Average Before = 0.94562602
Load Average After = 1.35706067
Average Load Average = 1.15134335
NIL
(meter:report)
Statistics
Meter for: GREVERSE
Entries = 50000
NULLs = 12525000
SETQs = 12673300
CDRs = 12524600
RPLACAs = 99600
CARs = 99600
PROGs = 49600
RPLACDs = 12424800
GOs = 4075500
Meter for: XREVERSE
Entries = 50000
PROGs = 50000
NULLs = 12525000
CDRs = 12475000
SETQs = 12475000
RPLACDs = 12475000
GOs = 4141700
T
Meter for: GREVERSE Meter for: XREVERSE
Entries = 50000 Entries = 50000
NULLs = 12525000 NULLs = 12525000
CDRs = 12574600 CDRs = 12524600
SETQs = 12673300 SETQs = 12475000
RPLACs = 12524400 RPLACDs = 12475000
PROGs = 49600 PROGs = 50000
GOs = 4075500 GOs = 4141700
(fasload nrevers)
(fasload meter)
(defun make-n (n)
(do ((n n (1- n))
(a () (push n a)))
((= n 0) (setq l a) t)))
(make-n 12.)
(greverse-init)(xreverse-init)
(progn (greverse l) t)
(progn (xreverse l) t)
(meter:report)
GREVERSE-ARRAY
XREVERSE-ARRAY
T
T
T
Statistics
Meter for: GREVERSE
Entries = 1
NULLs = 11
SETQs = 14
CAR-CDRs = 13
RPLACs = 11
PROGs = 1
GOs = 2
Meter for: XREVERSE
Entries = 1
PROGs = 1
NULLs = 11
CAR-CDRs = 10
SETQs = 10
RPLACs = 10
GOs = 3
T
T
GREVERSE-ARRAY
XREVERSE-ARRAY
T
T
Statistics
Meter for: GREVERSE
Entries = 1
NULLs = 12
SETQs = 15
CAR-CDRs = 14
RPLACs = 12
PROGs = 1
GOs = 2
Meter for: XREVERSE
Entries = 1
PROGs = 1
NULLs = 12
CAR-CDRs = 11
SETQs = 11
RPLACs = 11
GOs = 3
T
T
GREVERSE-ARRAY
XREVERSE-ARRAY
T
T
Statistics
Meter for: GREVERSE
Entries = 1
NULLs = 13
SETQs = 16
CAR-CDRs = 15
RPLACs = 13
PROGs = 1
GOs = 2
Meter for: XREVERSE
Entries = 1
PROGs = 1
NULLs = 13
CAR-CDRs = 12
SETQs = 12
RPLACs = 12
GOs = 4
T
(gtimitl)
Timing performed on Thursday 01/27/83 at 21:30:54.
Cpu (- GC) Time = 223.755
Elapsed Time = 925.78333
Wholine Time = 360.666668
GC Time = 0.0
Load Average Before = 2.2628181
Load Average After = 5.45643306
Average Load Average = 3.85962558
NIL
(xtimitl)
Timing performed on Thursday 01/27/83 at 21:47:29.
Cpu (- GC) Time = 225.898
Elapsed Time = 786.416664
Wholine Time = 376.35
GC Time = 0.0
Load Average Before = 4.54944575
Load Average After = 1.94856465
Average Load Average = 3.2490052
NIL
(meter:report)
Statistics
Meter for: GREVERSE Meter for: XREVERSE
Entries = 50000 Entries = 50000
NULLs = 12525000 NULLs = 12525000 0
SETQs = 12673300 SETQs = 12475000 +198300
CAR-CDRs = 12624200 CAR-CDRs = 12475000 +149200
RPLACs = 12524400 RPLACs = 12475000 + 49400
PROGs = 49600 PROGs = 50000 - 400
GOs = 4075500 GOs = 4141700 - 66200
(defun hack ()
(- (progn (read)(read)(read)) (progn (read)(read)(read))))
(fasload nrevers)
(gtimitl)
Timing performed on Saturday 01/29/83 at 18:14:29.
Cpu (- GC) Time = 44.171
Elapsed Time = 110.383333
Wholine Time = 73.166667
GC Time = 0.0
Load Average Before = 0.82098305
Load Average After = 1.40752971
Average Load Average = 1.11425638
NIL
(xtimitl)
Timing performed on Saturday 01/29/83 at 18:17:24.
Cpu (- GC) Time = 43.84
Elapsed Time = 108.766666
Wholine Time = 71.733334
GC Time = 0.0
Load Average Before = 1.00243688
Load Average After = 1.45095289
Average Load Average = 1.22669488
NIL
;;; SAIL (MODEL B)
(fasload nreverse)
(xtimits)
Timing performed on Friday 03/04/83 at 16:27:58.
Cpu (- GC) Time = 4.133
Elapsed Time = 8.2
Wholine Time = 6.6
GC Time = 0.0
Load Average Before = 0.90988505
Load Average After = 0.93491292
Average Load Average = 0.922398984
NIL
(gtimits)
Timing performed on Friday 03/04/83 at 16:28:14.
Cpu (- GC) Time = 4.368
Elapsed Time = 10.5
Wholine Time = 6.1666667
GC Time = 0.0
Load Average Before = 0.968218565
Load Average After = 1.03002763
Average Load Average = 0.9991231
NIL
(ktimits)
Timing performed on Friday 03/04/83 at 16:29:05.
Cpu (- GC) Time = 3.905
Elapsed Time = 13.5833334
Wholine Time = 6.5
GC Time = 0.0
Load Average Before = 1.22123373
Load Average After = 1.3665644
Average Load Average = 1.29389906
NIL
(ltimits)
Timing performed on Friday 03/04/83 at 16:28:36.
Cpu (- GC) Time = 5.446
Elapsed Time = 17.8833334
Wholine Time = 8.7166667
GC Time = 0.0
Load Average Before = 1.01124191
Load Average After = 1.2478466
Average Load Average = 1.12954426
NIL
(xtimitl)
Timing performed on Friday 03/04/83 at 16:30:34.
Cpu (- GC) Time = 40.517
Elapsed Time = 146.133333
Wholine Time = 71.25
GC Time = 0.0
Load Average Before = 0.95780206
Load Average After = 2.00175166
Average Load Average = 1.47977686
NIL
(gtimitl)
Timing performed on Friday 03/04/83 at 16:33:05.
Cpu (- GC) Time = 37.963
Elapsed Time = 107.8
Wholine Time = 67.5
GC Time = 0.0
Load Average Before = 1.95711017
Load Average After = 2.01296973
Average Load Average = 1.98503995
NIL
(ktimitl)
Timing performed on Friday 03/04/83 at 16:35:01.
Cpu (- GC) Time = 37.672
Elapsed Time = 88.916667
Wholine Time = 60.75
GC Time = 0.0
Load Average Before = 1.93647516
Load Average After = 1.87217343
Average Load Average = 1.9043243
NIL
(ltimitl)
Timing performed on Friday 03/04/83 at 16:36:34.
Cpu (- GC) Time = 61.197
Elapsed Time = 136.983334
Wholine Time = 99.433333
GC Time = 0.0
Load Average Before = 1.84041739
Load Average After = 1.70235217
Average Load Average = 1.77138478
NIL
(xtimitss)
Timing performed on Friday 03/04/83 at 17:00:25.
Cpu (- GC) Time = 1.43
Elapsed Time = 4.0
Wholine Time = 2.0
GC Time = 0.0
Load Average Before = 1.89416564
Load Average After = 1.90643787
Average Load Average = 1.90030175
NIL
(ktimitss)
Timing performed on Friday 03/04/83 at 17:00:39.
Cpu (- GC) Time = 1.37
Elapsed Time = 3.83333334
Wholine Time = 2.18333334
GC Time = 0.0
Load Average Before = 1.85959291
Load Average After = 1.86399579
Average Load Average = 1.86179435
NIL
(gtimitss)
Timing performed on Friday 03/04/83 at 17:00:48.
Cpu (- GC) Time = 1.535
Elapsed Time = 3.21666667
Wholine Time = 2.48333332
GC Time = 0.0
Load Average Before = 1.81902671
Load Average After = 1.81339347
Average Load Average = 1.81621009
NIL
(ltimitss)
Timing performed on Friday 03/04/83 at 17:00:58.
Cpu (- GC) Time = 1.972
Elapsed Time = 4.1333333
Wholine Time = 2.88333333
GC Time = 0.0
Load Average Before = 1.75778079
Load Average After = 1.75754666
Average Load Average = 1.75766373
NIL
(ntimitss)
Timing performed on Friday 03/04/83 at 17:01:07.
Cpu (- GC) Time = 0.82
Elapsed Time = 4.3
Wholine Time = 1.23333333
GC Time = 0.0
Load Average Before = 1.73366177
Load Average After = 1.80790186
Average Load Average = 1.77078182
NIL
Why is Kreverse faster than Greverse in the 0-7(10000) case?
(defun kreverse (current)
(prog (next previous)
(cond ((null current)(return ())))
b
(setq next (cdr current))
(rplacd current previous)
(cond ((null next)(return current)))
(setq previous (cdr next))
(rplacd next current)
(cond ((null previous)(return next)))
(setq current (cdr previous))
(rplacd previous next)
(cond ((null current)(return previous)))
(go b)))
(defun greverse (current)
(let (x y)
(cond ((or (null current)
(null
(setq x
(cdr current))))
current)
((null
(setq y
(cdr x)))
(rplaca current
(prog1 (car x)
(rplaca x
(car current))))
current)
((null
(cdr y))
(rplaca current
(prog1 (car y)
(rplaca y
(car current))))
current)
(t (prog (next previous first second)
(setq first current second x)
(setq previous y next x)
(setq current (cdr previous))
b
(rplacd previous next)
(setq next (cdr current))
(cond ((null next)
(rplaca first
(prog1 (car current)
(rplaca current
(car first))))
(rplacd first previous)
(rplacd second current)
(return first)))
(rplacd current previous)
(setq previous (cdr next))
(cond ((null previous)
(rplaca first
(prog1 (car next)
(rplaca next
(car first))))
(rplacd first current)
(rplacd second next)
(return first)))
(rplacd next current)
(setq current (cdr previous))
(cond ((null current)
(rplaca first
(prog1 (car previous)
(rplaca previous
(car first))))
(rplacd first next)
(rplacd second previous)
(return first)))
(go b))))))
(LAP KREVERSE SUBR)
(ARGS KREVERSE (() . 1))
(PUSH P 1)
(PUSH P (% 0 0 '() ))
(PUSH P (% 0 0 '() ))
(JUMPE 1 G0003) 0123
G0001
(HRRZ 1 @ -2 P) 123
(MOVE 5 0 P) 123
(HRRM 5 @ -2 P) 123
(MOVEM 1 -1 P) 123
(JUMPN 1 G0005) 123
(MOVE 1 -2 P) 1
(JSP T PDLNMK) 1
(JRST 0 G0008) 1
G0005
(HRRZ 2 0 1) 23
(MOVE 1 -2 P) 23
(JSP T PDLNMK) 23
(HRRM 1 @ -1 P) 23
(MOVEM 2 0 P) 23
(JUMPN 2 G0011) 23
(MOVE 1 -1 P) 2
(JRST 0 G0008) 2
G0011
(HRRZ 3 0 2) 3
(MOVE 1 -1 P) 3
(HRRM 1 0 2) 3
(MOVEM 3 -2 P) 3
(JUMPN 3 G0001) 3
(MOVEI 1 0 2) 3
(JRST 0 G0008) 3
G0003
(MOVEI 1 '() ) 0
G0008
(SUB P (% 0 0 3 3)) 0123
(JRST 0 PDLNKJ) 0123
()
(LAP GREVERSE SUBR)
(ARGS GREVERSE (() . 1))
(PUSH P 1)
(PUSH P (% 0 0 '() ))
(PUSH P (% 0 0 '() ))
(JUMPE 1 G0004) 0123
(HRRZ 1 0 1) 123
(MOVEM 1 0 P) 123
(JUMPN 1 G0003) 123
G0004
(MOVE 1 -2 P) 1
(JSP T PDLNMK) 1
(JRST 0 G0002) 1
G0003
(HRRZ 1 0 1) 23
(MOVEM 1 -1 P) 23
(JUMPN 1 G0007) 23
(HLRZ 1 @ 0 P) 2
(PUSH P 1) 2
(HLRZ 1 @ -3 P) 2
(HRLM 1 @ -1 P) 2
(POP P 1) 2
(HRLM 1 @ -2 P) 2
(MOVE 1 -2 P) 2
(JSP T PDLNMK) 2
(JRST 0 G0002) 2
G0007
(HRRZ 2 0 1) 3
(JUMPN 2 G0012) 3
(HLRZ 1 0 1) 3
(PUSH P 1) 3
(HLRZ 1 @ -3 P) 3
(HRLM 1 @ -2 P) 3
(POP P 1) 3
(HRLM 1 @ -2 P) 3
(MOVE 1 -2 P) 3
(JSP T PDLNMK) 3
(JRST 0 G0002) 3
G0012
(MOVE 1 -2 P)
(JSP T PDLNMK)
(PUSH P 0 P)
(PUSH P -2 P)
(PUSH P -2 P)
(HRRZ 3 @ -1 P)
(PUSH P 1)
(MOVEM 3 -6 P)
G0001
(MOVE 1 -1 P)
(HRRM 1 @ -2 P)
(HRRZ 2 @ -6 P)
(MOVEM 2 -1 P)
(JUMPN 2 G0021)
(HLRZ 1 @ -6 P)
(PUSH P 1)
(HLRZ 1 @ -1 P)
(HRLM 1 @ -7 P)
(POP P 1)
(HRLM 1 @ 0 P)
(MOVE 1 -2 P)
(HRRM 1 @ 0 P)
(MOVE 1 -6 P)
(JSP T PDLNMK)
(HRRM 1 @ -3 P)
(MOVE 1 0 P)
(JRST 0 G0026)
G0021
(MOVE 1 -2 P)
(HRRM 1 @ -6 P)
(HRRZ 3 0 2)
(MOVEM 3 -2 P)
(JUMPN 3 G0028)
(HLRZ 1 0 2)
(PUSH P 1)
(HLRZ 1 @ -1 P)
(HRLM 1 0 2)
(POP P 1)
(HRLM 1 @ 0 P)
(MOVE 1 -6 P)
(JSP T PDLNMK)
(HRRM 1 @ 0 P)
(HRRM 2 @ -3 P)
(MOVE 1 0 P)
(JRST 0 G0026)
G0028
(MOVE 1 -6 P)
(JSP T PDLNMK)
(HRRM 1 0 2)
(HRRZ 4 0 3)
(MOVEM 4 -6 P)
(JUMPN 4 G0001)
(HLRZ 1 0 3)
(PUSH P 1)
(HLRZ 1 @ -1 P)
(HRLM 1 0 3)
(POP P 1)
(HRLM 1 @ 0 P)
(HRRM 2 @ 0 P)
(HRRM 3 @ -3 P)
(MOVE 1 0 P)
G0026
(SUB P (% 0 0 4 4))
G0002
(SUB P (% 0 0 3 3)) 0123
(POPJ P) 0123
()
Here are the instruction counts for the cases 0-3:
Kreverse:
instr 0 1 2 3
--------------------------
jump 2 4 5 6
move 1 3 5 7
popj
push/pop
h??? 2 4 6
jsp 1 1 1
sub 1 1 1 1
--------------------------
total 4 11 16 21
Greverse
instr 0 1 2 3
--------------------------
jump 1 3 4 5
move 2 3 3
popj 1 1 1 1
push/pop 2 2
h??? 1 6 7
jsp 1 1 1
sub 1 1 1 1
--------------------------
total 3 9 12 20
(fasload nreverse)
(gtimitsss)
Timing performed on Thursday 03/17/83 at 10:56:13.
Cpu (- GC) Time = 2.028
Elapsed Time = 7.9
Wholine Time = 2.8
GC Time = 0.0
Load Average Before = 0.847022414
Load Average After = 0.949344754
Average Load Average = 0.898183584
NIL
(ktimitsss)
Timing performed on Thursday 03/17/83 at 10:56:26.
Cpu (- GC) Time = 2.048
Elapsed Time = 7.0833333
Wholine Time = 3.03333333
GC Time = 0.0
Load Average Before = 0.96173644
Load Average After = 1.04507399
Average Load Average = 1.00340521
NIL
(xtimitsss)
Timing performed on Thursday 03/17/83 at 10:56:48.
Cpu (- GC) Time = 2.114
Elapsed Time = 3.71666667
Wholine Time = 2.83333334
GC Time = 0.0
Load Average Before = 1.00266683
Load Average After = 1.02024591
Average Load Average = 1.01145637
NIL
(ltimitsss)
Timing performed on Thursday 03/17/83 at 10:56:56.
Cpu (- GC) Time = 3.054
Elapsed Time = 5.3333333
Wholine Time = 3.96666667
GC Time = 0.0
Load Average Before = 1.00687647
Load Average After = 1.02100575
Average Load Average = 1.01394111
NIL
(ntimitsss)
Timing performed on Thursday 03/17/83 at 10:57:05.
Cpu (- GC) Time = 1.308
Elapsed Time = 2.2
Wholine Time = 1.86666666
GC Time = 0.0
Load Average Before = 1.00025463
Load Average After = 1.00341952
Average Load Average = 1.00183707
NIL
COMMENT ⊗ VALID 00002 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 (fasload traverse)
C00005 ENDMK
C⊗;
(fasload traverse)
(init-timit)
(timit)
Timing performed on Monday 04/04/83 at 12:51:18.
Cpu (- GC) Time = 6.689
Elapsed Time = 391.633335
Wholine Time = 90.15
GC Time = 45.174
Load Average Before = 1.34567666
Load Average After = 5.16910934
Average Load Average = 3.257393
NIL
Timing performed on Monday 04/04/83 at 12:57:51.
Cpu (- GC) Time = 24.014
Elapsed Time = 241.833334
Wholine Time = 49.2166667
GC Time = 0.0
Load Average Before = 5.1550678
Load Average After = 4.9717611
Average Load Average = 5.06341445
NIL
Timing performed on Monday 04/04/83 at 13:01:54.
Cpu (- GC) Time = 23.989
Elapsed Time = 118.866667
Wholine Time = 48.016667
GC Time = 0.0
Load Average Before = 4.95022345
Load Average After = 3.74252367
Average Load Average = 4.34637356
NIL
Timing performed on Monday 04/04/83 at 13:03:54.
Cpu (- GC) Time = 23.993
Elapsed Time = 95.2
Wholine Time = 49.766667
GC Time = 0.0
Load Average Before = 3.68303668
Load Average After = 3.02455235
Average Load Average = 3.35379452
NIL
(TIMIT)
Timing performed on Monday 06/13/83 at 12:19:04.
Cpu (- GC) Time = 6.687
Elapsed Time = 186.533333
Wholine Time = 81.316667
GC Time = 45.135
Load Average Before = 3.12555504
Load Average After = 3.16852546
Average Load Average = 3.14704025
NIL
Timing performed on Monday 06/13/83 at 12:22:13.
Cpu (- GC) Time = 23.96
Elapsed Time = 84.7
Wholine Time = 43.9333334
GC Time = 0.0
Load Average Before = 3.1394682
Load Average After = 2.77139103
Average Load Average = 2.9554296
NIL